Graphics Plus/Graphics Plus.iso/msdos/compresn/dvpeg/src1b/jquant2.asm

Assembly Source File | 1992-06-09 | 80.6 KB | 4,015 lines

    .286p
    ifndef    ??version
publicdll macro    name
    public    name
    endm
$comm    macro    name,dist,size,count
    comm    dist name:BYTE:count*size
    endm
    else
$comm    macro    name,dist,size,count
    comm    dist name[size]:BYTE:count
    endm
    endif
_TEXT    segment byte public 'CODE'
_TEXT    ends
DGROUP    group    _DATA,_BSS
    assume    cs:_TEXT,ds:DGROUP
_DATA    segment word public 'DATA'
d@    label    byte
d@w    label    word
_DATA    ends
_BSS    segment word public 'BSS'
b@    label    byte
b@w    label    word
_BSS    ends
_TEXT    segment byte public 'CODE'
    ;
    ;    METHODDEF void
   ;
    assume    cs:_TEXT
color_quant_prescan    proc    near
    push    bp
    mov    bp,sp
    sub    sp,26
    push    si
    push    di
   ;
   ;    color_quant_prescan (decompress_info_ptr cinfo, int num_rows,
   ;                 JSAMPIMAGE image_data, JSAMPARRAY workspace)
   ;    {
   ;      register JSAMPROW ptr0, ptr1, ptr2;
   ;      register histptr histp;
   ;      register int c0, c1, c2;
   ;      int row;
    ;      long col;
   ;
    mov    bx,word ptr [bp+4]
    mov    ax,word ptr [bx+38]
    mov    dx,word ptr [bx+36]
    mov    word ptr [bp-24],ax
    mov    word ptr [bp-26],dx
   ;
   ;      long width = cinfo->image_width;
   ;
   ;
    mov    word ptr [bp-18],0
    jmp    @1@242
@1@50:
   ;
   ;      for (row = 0; row < num_rows; row++) {
   ;
    mov    ax,word ptr [bp-18]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
    ;        ptr0 = image_data[0][row];
   ;
    mov    ax,word ptr [bp-18]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx+2]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-6],ax
    mov    word ptr [bp-8],dx
   ;
   ;        ptr1 = image_data[1][row];
   ;
    mov    ax,word ptr [bp-18]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx+4]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-10],ax
    mov    word ptr [bp-12],dx
   ;
   ;        ptr2 = image_data[2][row];
   ;
    mov    ax,word ptr [bp-24]
    mov    dx,word ptr [bp-26]
    mov    word ptr [bp-20],ax
    mov    word ptr [bp-22],dx
    jmp    short @1@146
@1@74:
   ;
   ;        for (col = width; col > 0; col--) {
   ;          /* get pixel value and index into the histogram */
   ;
    les    bx,dword ptr [bp-4]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sar    ax,2
    mov    si,ax
    inc    word ptr [bp-4]
    ;
    ;          c0 = GETJSAMPLE(*ptr0++) >> Y_SHIFT;
    ;
    les    bx,dword ptr [bp-8]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sar    ax,3
    mov    di,ax
    inc    word ptr [bp-8]
   ;
   ;          c1 = GETJSAMPLE(*ptr1++) >> C_SHIFT;
   ;
    les    bx,dword ptr [bp-12]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sar    ax,3
    mov    cx,ax
    inc    word ptr [bp-12]
   ;
   ;          c2 = GETJSAMPLE(*ptr2++) >> C_SHIFT;
   ;
    mov    ax,si
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,di
    shl    bx,6
    add    dx,bx
    mov    bx,cx
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-14],ax
    mov    word ptr [bp-16],dx
   ;
   ;          histp = & histogram[c0][c1][c2];
   ;          /* increment, check for overflow and undo increment if so. */
   ;          /* We assume unsigned representation here! */
   ;
    les    bx,dword ptr [bp-16]
    inc    word ptr es:[bx]
    mov    ax,word ptr es:[bx]
    or    ax,ax
    jne    short @1@122
   ;
   ;          if (++(*histp) == 0)
   ;
    dec    word ptr es:[bx]
@1@122:
    sub    word ptr [bp-22],1
    sbb    word ptr [bp-20],0
@1@146:
    cmp    word ptr [bp-20],0
    jg    short @1@74
    jne    short @1@218
    cmp    word ptr [bp-22],0
    jbe    @@0
    jmp    @1@74
@@0:
@1@218:
    inc    word ptr [bp-18]
@1@242:
    mov    ax,word ptr [bp-18]
    cmp    ax,word ptr [bp+6]
    jge    @@1
    jmp    @1@50
@@1:
   ;
   ;        (*histp)--;
   ;        }
   ;      }
   ;
    pop    di
    pop    si
    leave
    ret
color_quant_prescan    endp
   ;
   ;    LOCAL boxptr
   ;
    assume    cs:_TEXT
find_biggest_color_pop    proc    near
    push    bp
    mov    bp,sp
    sub    sp,4
    push    si
    push    di
    ;
    ;    find_biggest_color_pop (void)
   ;    /* Find the splittable box with the largest color population */
   ;    /* Returns NULL if no splittable boxes remain */
   ;    {
   ;      register boxptr boxp;
   ;      register int i;
   ;
    mov    word ptr [bp-2],0
    mov    word ptr [bp-4],0
   ;
   ;      register long max = 0;
   ;
    xor    bx,bx
   ;
   ;      boxptr which = NULL;
   ;
   ;
    xor    di,di
    mov    si,word ptr DGROUP:boxlist
    jmp    short @2@242
@2@50:
   ;
   ;      for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {
   ;
    mov    ax,word ptr [si+14]
    mov    dx,word ptr [si+12]
    cmp    ax,word ptr [bp-2]
    jl    short @2@218
    jg    short @2@122
    cmp    dx,word ptr [bp-4]
    jbe    short @2@218
@2@122:
   ;
   ;        if (boxp->colorcount > max) {
   ;
   ;
   ;          if (boxp->c0max > boxp->c0min || boxp->c1max > boxp->c1min ||
   ;
    mov    ax,word ptr [si+2]
    cmp    ax,word ptr [si]
    jg    short @2@194
    mov    ax,word ptr [si+6]
    cmp    ax,word ptr [si+4]
    jg    short @2@194
    mov    ax,word ptr [si+10]
    cmp    ax,word ptr [si+8]
    jle    short @2@218
@2@194:
   ;
   ;          boxp->c2max > boxp->c2min) {
   ;
    mov    bx,si
   ;
   ;        which = boxp;
   ;
    mov    ax,word ptr [si+14]
    mov    dx,word ptr [si+12]
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
@2@218:
    inc    di
    add    si,16
@2@242:
    cmp    di,word ptr DGROUP:numboxes
    jl    short @2@50
   ;
   ;        max = boxp->colorcount;
   ;          }
   ;        }
   ;      }
   ;
    mov    ax,bx
   ;
   ;      return which;
   ;
    pop    di
    pop    si
    leave
    ret
find_biggest_color_pop    endp
   ;
   ;    LOCAL boxptr
   ;
    assume    cs:_TEXT
find_biggest_volume    proc    near
    push    bp
    mov    bp,sp
    sub    sp,22
    push    si
    push    di
   ;
   ;    find_biggest_volume (void)
   ;    /* Find the splittable box with the largest (scaled) volume */
   ;    /* Returns NULL if no splittable boxes remain */
   ;    {
   ;      register boxptr boxp;
   ;      register int i;
   ;
    mov    word ptr [bp-2],0
    mov    word ptr [bp-4],0
   ;
   ;      register INT32 max = 0;
   ;      register INT32 norm, c0,c1,c2;
   ;
    mov    word ptr [bp-22],0
   ;
   ;      boxptr which = NULL;
   ;
   ;      /* We use 2-norm rather than real volume here.
   ;       * Some care is needed since the differences are expressed in
   ;       * histogram-cell units; if HIST_Y_BITS != HIST_C_BITS, we have to
   ;       * adjust the scaling to get the proper scaled-YCbCr-space distance.
   ;       * This code won't work right if HIST_Y_BITS < HIST_C_BITS,
   ;       * but that shouldn't ever be true.
   ;       * Note norm > 0 iff box is splittable, so need not check separately.
   ;       */
   ;
   ;
    xor    di,di
    mov    si,word ptr DGROUP:boxlist
    jmp    @3@170
@3@50:
   ;
   ;      for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {
   ;
    mov    ax,word ptr [si+2]
    sub    ax,word ptr [si]
    shl    ax,1
.386
movsx    eax, ax
mov    [bp-12], eax
.286
    ;
    ;        c0 = (boxp->c0max - boxp->c0min) * Y_SCALE;
    ;
    mov    ax,word ptr [si+6]
    sub    ax,word ptr [si+4]
    shl    ax,1
.386
movsx    ebx, ax
mov    [bp-16], ebx
.286
    ;
    ;        c1 = (boxp->c1max - boxp->c1min) << (HIST_Y_BITS-HIST_C_BITS);
    ;
    mov    ax,word ptr [si+10]
    sub    ax,word ptr [si+8]
    shl    ax,1
.386
movsx    ecx, ax
mov    [bp-20], ecx
    ;
    ;        c2 = (boxp->c2max - boxp->c2min) << (HIST_Y_BITS-HIST_C_BITS);
    ;
imul    eax, eax
imul    ebx, ebx
imul    ecx, ecx
add    eax, ebx
add    eax, ecx
mov    [bp-8], eax
.286
    ;
    ;        norm = c0*c0 + c1*c1 + c2*c2;
    ;
    mov    ax,word ptr [bp-6]
    mov    dx,word ptr [bp-8]
    cmp    ax,word ptr [bp-2]
    jl    short @3@146
    jg    short @3@122
    cmp    dx,word ptr [bp-4]
    jbe    short @3@146
@3@122:
    ;
    ;        if (norm > max) {
    ;
    mov    word ptr [bp-22],si
    ;
   ;          which = boxp;
   ;
    mov    ax,word ptr [bp-6]
    mov    dx,word ptr [bp-8]
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
@3@146:
    inc    di
    add    si,16
@3@170:
    cmp    di,word ptr DGROUP:numboxes
    jge    @@2
    jmp    @3@50
@@2:
   ;
   ;          max = norm;
   ;        }
   ;      }
   ;
    mov    ax,word ptr [bp-22]
   ;
   ;      return which;
   ;
    pop    di
    pop    si
    leave
    ret
find_biggest_volume    endp
    ;
   ;    LOCAL void
   ;
    assume    cs:_TEXT
update_box    proc    near
    push    bp
    mov    bp,sp
    sub    sp,20
    push    si
    push    di
   ;
   ;    update_box (boxptr boxp)
   ;    /* Shrink the min/max bounds of a box to enclose only nonzero elements, */
   ;    /* and recompute its population */
   ;    {
   ;      histptr histp;
   ;      int c0,c1,c2;
   ;      int c0min,c0max,c1min,c1max,c2min,c2max;
   ;      long ccount;
   ;
   ;
    mov    bx,word ptr [bp+4]
    mov    ax,word ptr [bx]
    mov    word ptr [bp-6],ax
    mov    ax,word ptr [bx+2]
    mov    word ptr [bp-8],ax
   ;
   ;      c0min = boxp->c0min;  c0max = boxp->c0max;
   ;
    mov    ax,word ptr [bx+4]
    mov    word ptr [bp-10],ax
    mov    ax,word ptr [bx+6]
    mov    word ptr [bp-12],ax
   ;
   ;      c1min = boxp->c1min;  c1max = boxp->c1max;
   ;
    mov    ax,word ptr [bx+8]
    mov    word ptr [bp-14],ax
    mov    ax,word ptr [bx+10]
    mov    word ptr [bp-16],ax
   ;
   ;      c2min = boxp->c2min;  c2max = boxp->c2max;
   ;
   ;
    mov    ax,word ptr [bp-8]
    cmp    ax,word ptr [bp-6]
    jle    short @4@314
   ;
   ;      if (c0max > c0min)
   ;
    mov    ax,word ptr [bp-6]
    mov    cx,ax
    jmp    short @4@290
@4@74:
   ;
   ;        for (c0 = c0min; c0 <= c0max; c0++)
   ;
    mov    di,word ptr [bp-10]
    jmp    short @4@242
@4@98:
   ;
   ;          for (c1 = c1min; c1 <= c1max; c1++) {
   ;
    mov    ax,cx
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,di
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp-14]
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;        histp = & histogram[c0][c1][c2min];
   ;
    mov    si,word ptr [bp-14]
    jmp    short @4@194
@4@122:
    ;
   ;        for (c2 = c2min; c2 <= c2max; c2++)
   ;
    les    bx,dword ptr [bp-4]
    add    word ptr [bp-4],2
    cmp    word ptr es:[bx],0
    je    short @4@170
   ;
   ;          if (*histp++ != 0) {
   ;
    mov    ax,cx
    mov    word ptr [bp-6],ax
    mov    bx,word ptr [bp+4]
    mov    word ptr [bx],ax
   ;
   ;            boxp->c0min = c0min = c0;
   ;
    jmp    short @4@314
@4@170:
    inc    si
@4@194:
    cmp    si,word ptr [bp-16]
    jle    short @4@122
    inc    di
@4@242:
    cmp    di,word ptr [bp-12]
    jle    short @4@98
    inc    cx
@4@290:
    mov    ax,cx
    cmp    ax,word ptr [bp-8]
    jle    short @4@74
@4@314:
   ;
   ;            goto have_c0min;
   ;          }
   ;          }
   ;     have_c0min:
   ;
    mov    ax,word ptr [bp-8]
    cmp    ax,word ptr [bp-6]
    jle    short @4@602
   ;
   ;      if (c0max > c0min)
    ;
    mov    cx,ax
    jmp    short @4@578
@4@362:
   ;
    ;        for (c0 = c0max; c0 >= c0min; c0--)
   ;
    mov    di,word ptr [bp-10]
    jmp    short @4@530
@4@386:
   ;
   ;          for (c1 = c1min; c1 <= c1max; c1++) {
   ;
    mov    ax,cx
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,di
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp-14]
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;        histp = & histogram[c0][c1][c2min];
   ;
    mov    si,word ptr [bp-14]
    jmp    short @4@482
@4@410:
   ;
   ;        for (c2 = c2min; c2 <= c2max; c2++)
   ;
    les    bx,dword ptr [bp-4]
    add    word ptr [bp-4],2
    cmp    word ptr es:[bx],0
    je    short @4@458
   ;
   ;          if (*histp++ != 0) {
   ;
    mov    ax,cx
    mov    word ptr [bp-8],ax
    mov    bx,word ptr [bp+4]
    mov    word ptr [bx+2],ax
   ;
   ;            boxp->c0max = c0max = c0;
    ;
    jmp    short @4@602
@4@458:
    inc    si
@4@482:
    cmp    si,word ptr [bp-16]
    jle    short @4@410
    inc    di
@4@530:
    cmp    di,word ptr [bp-12]
    jle    short @4@386
    dec    cx
@4@578:
    mov    ax,cx
    cmp    ax,word ptr [bp-6]
    jge    short @4@362
@4@602:
   ;
   ;            goto have_c0max;
   ;          }
   ;          }
   ;     have_c0max:
   ;
    mov    ax,word ptr [bp-12]
    cmp    ax,word ptr [bp-10]
    jle    short @4@890
   ;
   ;      if (c1max > c1min)
   ;
    mov    di,word ptr [bp-10]
    jmp    short @4@866
@4@650:
   ;
   ;        for (c1 = c1min; c1 <= c1max; c1++)
   ;
    mov    ax,word ptr [bp-6]
    mov    cx,ax
    jmp    short @4@818
@4@674:
    ;
   ;          for (c0 = c0min; c0 <= c0max; c0++) {
   ;
    mov    ax,cx
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,di
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp-14]
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;        histp = & histogram[c0][c1][c2min];
   ;
    mov    si,word ptr [bp-14]
    jmp    short @4@770
@4@698:
   ;
   ;        for (c2 = c2min; c2 <= c2max; c2++)
   ;
    les    bx,dword ptr [bp-4]
    add    word ptr [bp-4],2
    cmp    word ptr es:[bx],0
    je    short @4@746
   ;
   ;          if (*histp++ != 0) {
   ;
    mov    ax,di
    mov    word ptr [bp-10],ax
    mov    bx,word ptr [bp+4]
    mov    word ptr [bx+4],ax
   ;
   ;            boxp->c1min = c1min = c1;
   ;
    jmp    short @4@890
@4@746:
    inc    si
@4@770:
    cmp    si,word ptr [bp-16]
    jle    short @4@698
    inc    cx
@4@818:
    mov    ax,cx
    cmp    ax,word ptr [bp-8]
    jle    short @4@674
    inc    di
@4@866:
    cmp    di,word ptr [bp-12]
    jle    short @4@650
@4@890:
   ;
   ;            goto have_c1min;
   ;          }
   ;          }
   ;     have_c1min:
   ;
    mov    ax,word ptr [bp-12]
    cmp    ax,word ptr [bp-10]
    jle    short @4@1178
   ;
   ;      if (c1max > c1min)
   ;
    mov    di,word ptr [bp-12]
    jmp    short @4@1154
@4@938:
   ;
   ;        for (c1 = c1max; c1 >= c1min; c1--)
   ;
    mov    ax,word ptr [bp-6]
    mov    cx,ax
    jmp    short @4@1106
@4@962:
   ;
   ;          for (c0 = c0min; c0 <= c0max; c0++) {
   ;
    mov    ax,cx
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,di
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp-14]
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;        histp = & histogram[c0][c1][c2min];
   ;
    mov    si,word ptr [bp-14]
    jmp    short @4@1058
@4@986:
   ;
   ;        for (c2 = c2min; c2 <= c2max; c2++)
   ;
    les    bx,dword ptr [bp-4]
    add    word ptr [bp-4],2
    cmp    word ptr es:[bx],0
    je    short @4@1034
   ;
   ;          if (*histp++ != 0) {
   ;
    mov    ax,di
    mov    word ptr [bp-12],ax
    mov    bx,word ptr [bp+4]
    mov    word ptr [bx+6],ax
   ;
   ;            boxp->c1max = c1max = c1;
   ;
    jmp    short @4@1178
@4@1034:
    inc    si
@4@1058:
    cmp    si,word ptr [bp-16]
    jle    short @4@986
    inc    cx
@4@1106:
    mov    ax,cx
    cmp    ax,word ptr [bp-8]
    jle    short @4@962
    dec    di
@4@1154:
    cmp    di,word ptr [bp-10]
    jge    short @4@938
@4@1178:
   ;
   ;            goto have_c1max;
   ;          }
    ;          }
   ;     have_c1max:
   ;
    mov    ax,word ptr [bp-16]
    cmp    ax,word ptr [bp-14]
    jle    short @4@1466
   ;
   ;      if (c2max > c2min)
   ;
    mov    si,word ptr [bp-14]
    jmp    short @4@1442
@4@1226:
   ;
   ;        for (c2 = c2min; c2 <= c2max; c2++)
   ;
    mov    ax,word ptr [bp-6]
    mov    cx,ax
    jmp    short @4@1394
@4@1250:
   ;
   ;          for (c0 = c0min; c0 <= c0max; c0++) {
   ;
    mov    ax,cx
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,word ptr [bp-10]
    shl    bx,6
    add    dx,bx
    mov    bx,si
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;        histp = & histogram[c0][c1min][c2];
   ;
    mov    di,word ptr [bp-10]
    jmp    short @4@1346
@4@1274:
   ;
   ;        for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C_ELEMS)
    ;
    les    bx,dword ptr [bp-4]
    cmp    word ptr es:[bx],0
    je    short @4@1322
   ;
   ;          if (*histp != 0) {
   ;
    mov    ax,si
    mov    word ptr [bp-14],ax
    mov    bx,word ptr [bp+4]
    mov    word ptr [bx+8],ax
   ;
   ;            boxp->c2min = c2min = c2;
   ;
    jmp    short @4@1466
@4@1322:
    inc    di
    add    word ptr [bp-4],64
@4@1346:
    cmp    di,word ptr [bp-12]
    jle    short @4@1274
    inc    cx
@4@1394:
    mov    ax,cx
    cmp    ax,word ptr [bp-8]
    jle    short @4@1250
    inc    si
@4@1442:
    cmp    si,word ptr [bp-16]
    jle    short @4@1226
@4@1466:
   ;
   ;            goto have_c2min;
   ;          }
   ;          }
   ;     have_c2min:
   ;
    mov    ax,word ptr [bp-16]
    cmp    ax,word ptr [bp-14]
    jle    short @4@1754
   ;
   ;      if (c2max > c2min)
   ;
    mov    si,word ptr [bp-16]
    jmp    short @4@1730
@4@1514:
   ;
   ;        for (c2 = c2max; c2 >= c2min; c2--)
   ;
    mov    ax,word ptr [bp-6]
    mov    cx,ax
    jmp    short @4@1682
@4@1538:
   ;
   ;          for (c0 = c0min; c0 <= c0max; c0++) {
   ;
    mov    ax,cx
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,word ptr [bp-10]
    shl    bx,6
    add    dx,bx
    mov    bx,si
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;        histp = & histogram[c0][c1min][c2];
   ;
    mov    di,word ptr [bp-10]
    jmp    short @4@1634
@4@1562:
   ;
   ;        for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C_ELEMS)
   ;
    les    bx,dword ptr [bp-4]
    cmp    word ptr es:[bx],0
    je    short @4@1610
   ;
    ;          if (*histp != 0) {
    ;
    mov    ax,si
    mov    word ptr [bp-16],ax
    mov    bx,word ptr [bp+4]
    mov    word ptr [bx+10],ax
   ;
   ;            boxp->c2max = c2max = c2;
   ;
    jmp    short @4@1754
@4@1610:
    inc    di
    add    word ptr [bp-4],64
@4@1634:
    cmp    di,word ptr [bp-12]
    jle    short @4@1562
    inc    cx
@4@1682:
    mov    ax,cx
    cmp    ax,word ptr [bp-8]
    jle    short @4@1538
    dec    si
@4@1730:
    cmp    si,word ptr [bp-14]
    jge    short @4@1514
@4@1754:
   ;
   ;            goto have_c2max;
   ;          }
   ;          }
   ;     have_c2max:
   ;
   ;      /* Now scan remaining volume of box and compute population */
   ;
    mov    word ptr [bp-18],0
    mov    word ptr [bp-20],0
   ;
   ;      ccount = 0;
   ;
    mov    ax,word ptr [bp-6]
    mov    cx,ax
    jmp    short @4@1994
@4@1778:
   ;
   ;      for (c0 = c0min; c0 <= c0max; c0++)
    ;
    mov    di,word ptr [bp-10]
    jmp    short @4@1946
@4@1802:
    ;
   ;        for (c1 = c1min; c1 <= c1max; c1++) {
   ;
    mov    ax,cx
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,di
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp-14]
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;          histp = & histogram[c0][c1][c2min];
   ;
    mov    si,word ptr [bp-14]
    jmp    short @4@1898
@4@1826:
   ;
   ;          for (c2 = c2min; c2 <= c2max; c2++, histp++)
   ;
    les    bx,dword ptr [bp-4]
    cmp    word ptr es:[bx],0
    je    short @4@1874
   ;
   ;        if (*histp != 0) {
   ;
    add    word ptr [bp-20],1
    adc    word ptr [bp-18],0
@4@1874:
    inc    si
    add    word ptr [bp-4],2
@4@1898:
    cmp    si,word ptr [bp-16]
    jle    short @4@1826
    inc    di
@4@1946:
    cmp    di,word ptr [bp-12]
    jle    short @4@1802
    inc    cx
@4@1994:
    mov    ax,cx
    cmp    ax,word ptr [bp-8]
    jle    short @4@1778
   ;
   ;          ccount++;
   ;        }
   ;        }
   ;
    mov    bx,word ptr [bp+4]
    mov    ax,word ptr [bp-18]
    mov    dx,word ptr [bp-20]
    mov    word ptr [bx+14],ax
    mov    word ptr [bx+12],dx
   ;
   ;      boxp->colorcount = ccount;
   ;
    pop    di
    pop    si
    leave
    ret
update_box    endp
   ;
   ;    LOCAL void
   ;
    assume    cs:_TEXT
median_cut    proc    near
    push    bp
    mov    bp,sp
    sub    sp,12
    push    si
    push    di
    jmp    @5@482
@5@50:
   ;
   ;    median_cut (int desired_colors)
   ;    /* Repeatedly select and split the largest box until we have enough boxes */
   ;    {
   ;      int n,lb;
    ;      int c0,c1,c2,cmax;
   ;      register boxptr b1,b2;
   ;
   ;      while (numboxes < desired_colors) {
    ;        /* Select box to split */
   ;        /* Current algorithm: by population for first half, then by volume */
   ;
    mov    ax,word ptr DGROUP:numboxes
    shl    ax,1
    cmp    ax,word ptr [bp+4]
    jg    short @5@98
   ;
   ;        if (numboxes*2 <= desired_colors) {
   ;
    call    near ptr find_biggest_color_pop
    jmp    short @5@122
@5@98:
   ;
   ;          b1 = find_biggest_color_pop();
   ;        } else {
   ;
    call    near ptr find_biggest_volume
@5@122:
    mov    si,ax
   ;
   ;          b1 = find_biggest_volume();
   ;        }
   ;
    or    si,si
    jne    @@3
    jmp    @5@506
@@3:
   ;
   ;        if (b1 == NULL)        /* no splittable boxes left! */
   ;          break;
   ;
    mov    ax,word ptr DGROUP:numboxes
    shl    ax,4
    mov    dx,word ptr DGROUP:boxlist
    add    dx,ax
    mov    di,dx
   ;
   ;        b2 = &boxlist[numboxes];    /* where new box will go */
   ;        /* Copy the color bounds to the new box. */
    ;
    mov    ax,word ptr [si+2]
    mov    word ptr [di+2],ax
    mov    ax,word ptr [si+6]
    mov    word ptr [di+6],ax
    mov    ax,word ptr [si+10]
    mov    word ptr [di+10],ax
   ;
   ;        b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max;
   ;
    mov    ax,word ptr [si]
    mov    word ptr [di],ax
    mov    ax,word ptr [si+4]
    mov    word ptr [di+4],ax
    mov    ax,word ptr [si+8]
    mov    word ptr [di+8],ax
   ;
   ;        b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min;
   ;        /* Choose which axis to split the box on.
   ;         * Current algorithm: longest scaled axis.
   ;         * See notes in find_biggest_volume about scaling...
   ;         */
   ;
    mov    ax,word ptr [si+2]
    sub    ax,word ptr [si]
    shl    ax,1
    mov    word ptr [bp-6],ax
   ;
   ;        c0 = (b1->c0max - b1->c0min) * Y_SCALE;
   ;
    mov    ax,word ptr [si+6]
    sub    ax,word ptr [si+4]
    shl    ax,1
    mov    word ptr [bp-8],ax
   ;
   ;        c1 = (b1->c1max - b1->c1min) << (HIST_Y_BITS-HIST_C_BITS);
   ;
    mov    ax,word ptr [si+10]
    sub    ax,word ptr [si+8]
    shl    ax,1
    mov    word ptr [bp-10],ax
   ;
   ;        c2 = (b1->c2max - b1->c2min) << (HIST_Y_BITS-HIST_C_BITS);
   ;
    mov    ax,word ptr [bp-6]
    mov    word ptr [bp-12],ax
    mov    word ptr [bp-2],0
   ;
    ;        cmax = c0; n = 0;
   ;
    mov    ax,word ptr [bp-8]
    cmp    ax,word ptr [bp-12]
    jle    short @5@218
    mov    word ptr [bp-12],ax
    mov    word ptr [bp-2],1
@5@218:
   ;
   ;        if (c1 > cmax) { cmax = c1; n = 1; }
   ;
    mov    ax,word ptr [bp-10]
    cmp    ax,word ptr [bp-12]
    jle    short @5@266
    mov    word ptr [bp-2],2
@5@266:
   ;
   ;        if (c2 > cmax) { n = 2; }
   ;        /* Choose split point along selected axis, and update box bounds.
   ;         * Current algorithm: split at halfway point.
   ;         * (Since the box has been shrunk to minimum volume,
   ;         * any split will produce two nonempty subboxes.)
   ;         * Note that lb value is max for lower box, so must be < old max.
   ;         */
   ;
    mov    ax,word ptr [bp-2]
    or    ax,ax
    je    short @5@386
    cmp    ax,1
    je    short @5@410
    cmp    ax,2
    je    short @5@434
    jmp    short @5@458
@5@386:
   ;
   ;        switch (n) {
   ;        case 0:
   ;
    mov    ax,word ptr [si+2]
    add    ax,word ptr [si]
    mov    bx,2
    cwd
    idiv    bx
    mov    word ptr [bp-4],ax
    ;
   ;          lb = (b1->c0max + b1->c0min) / 2;
   ;
    mov    word ptr [si+2],ax
   ;
   ;          b1->c0max = lb;
   ;
    inc    ax
    mov    word ptr [di],ax
   ;
   ;          b2->c0min = lb+1;
   ;
    jmp    short @5@458
@5@410:
   ;
   ;          break;
   ;        case 1:
   ;
    mov    ax,word ptr [si+6]
    add    ax,word ptr [si+4]
    mov    bx,2
    cwd
    idiv    bx
    mov    word ptr [bp-4],ax
   ;
   ;          lb = (b1->c1max + b1->c1min) / 2;
   ;
    mov    word ptr [si+6],ax
   ;
   ;          b1->c1max = lb;
   ;
    inc    ax
    mov    word ptr [di+4],ax
   ;
   ;          b2->c1min = lb+1;
   ;
    jmp    short @5@458
@5@434:
   ;
   ;          break;
    ;        case 2:
   ;
    mov    ax,word ptr [si+10]
    add    ax,word ptr [si+8]
    mov    bx,2
    cwd
    idiv    bx
    mov    word ptr [bp-4],ax
   ;
   ;          lb = (b1->c2max + b1->c2min) / 2;
   ;
    mov    word ptr [si+10],ax
   ;
   ;          b1->c2max = lb;
   ;
    inc    ax
    mov    word ptr [di+8],ax
   ;
   ;          b2->c2min = lb+1;
   ;
@5@458:
   ;
   ;          break;
   ;        }
   ;        /* Update stats for boxes */
   ;
    push    si
    call    near ptr update_box
    inc    sp
    inc    sp
   ;
   ;        update_box(b1);
   ;
    push    di
    call    near ptr update_box
    inc    sp
    inc    sp
   ;
   ;        update_box(b2);
   ;
    inc    word ptr DGROUP:numboxes
@5@482:
    mov    ax,word ptr DGROUP:numboxes
    cmp    ax,word ptr [bp+4]
    jge    @@4
    jmp    @5@50
@@4:
@5@506:
    ;
   ;        numboxes++;
   ;      }
   ;
    pop    di
    pop    si
    leave
    ret
median_cut    endp
   ;
   ;    LOCAL void
   ;
    assume    cs:_TEXT
compute_color    proc    near
    push    bp
    mov    bp,sp
    sub    sp,38
    push    si
    push    di
   ;
   ;    compute_color (boxptr boxp, int icolor)
   ;    /* Compute representative color for a box, put it in my_colormap[icolor] */
   ;    {
   ;      /* Current algorithm: mean weighted by pixels (not colors) */
   ;      /* Note it is important to get the rounding correct! */
   ;      histptr histp;
   ;      int c0,c1,c2;
   ;      int c0min,c0max,c1min,c1max,c2min,c2max;
   ;      long count;
   ;
    mov    word ptr [bp-24],0
    mov    word ptr [bp-26],0
   ;
   ;      long total = 0;
   ;
    mov    word ptr [bp-28],0
    mov    word ptr [bp-30],0
   ;
   ;      long c0total = 0;
   ;
    mov    word ptr [bp-32],0
    mov    word ptr [bp-34],0
    ;
   ;      long c1total = 0;
    ;
    mov    word ptr [bp-36],0
    mov    word ptr [bp-38],0
   ;
   ;      long c2total = 0;
   ;
   ;
    mov    bx,word ptr [bp+4]
    mov    ax,word ptr [bx]
    mov    word ptr [bp-8],ax
    mov    ax,word ptr [bx+2]
    mov    word ptr [bp-10],ax
   ;
   ;      c0min = boxp->c0min;  c0max = boxp->c0max;
   ;
    mov    ax,word ptr [bx+4]
    mov    word ptr [bp-12],ax
    mov    ax,word ptr [bx+6]
    mov    word ptr [bp-14],ax
   ;
   ;      c1min = boxp->c1min;  c1max = boxp->c1max;
   ;
    mov    ax,word ptr [bx+8]
    mov    word ptr [bp-16],ax
    mov    ax,word ptr [bx+10]
    mov    word ptr [bp-18],ax
   ;
   ;      c2min = boxp->c2min;  c2max = boxp->c2max;
   ;
   ;
    mov    ax,word ptr [bp-8]
    mov    word ptr [bp-6],ax
    jmp    @6@266
@6@50:
   ;
   ;      for (c0 = c0min; c0 <= c0max; c0++)
   ;
    mov    di,word ptr [bp-12]
    jmp    @6@218
@6@74:
    ;
   ;        for (c1 = c1min; c1 <= c1max; c1++) {
    ;
    mov    ax,word ptr [bp-6]
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,di
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp-16]
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;          histp = & histogram[c0][c1][c2min];
   ;
    mov    si,word ptr [bp-16]
    jmp    short @6@170
@6@98:
   ;
   ;          for (c2 = c2min; c2 <= c2max; c2++) {
   ;
    les    bx,dword ptr [bp-4]
    add    word ptr [bp-4],2
    mov    ax,word ptr es:[bx]
    xor    dx,dx
    mov    word ptr [bp-20],dx
    mov    word ptr [bp-22],ax
    or    ax,dx
    je    short @6@146
    ;
    ;        if ((count = *histp++) != 0) {
    ;
.386
mov    eax, [bp-22]
add    [bp-26], eax
    ;
    ;          total += count;
    ;
movsx edx, word ptr [bp-6]
shl    edx, 2
add    edx, 2
imul    edx, eax
add    [bp-30], edx
    ;
    ;          c0total += ((c0 << Y_SHIFT) + ((1<<Y_SHIFT)>>1)) * count;
    ;
movsx    edx, di
shl    edx, 3
add    edx, 4
imul    edx, eax
add    [bp-34], edx
    ;
    ;          c1total += ((c1 << C_SHIFT) + ((1<<C_SHIFT)>>1)) * count;
    ;
movsx    edx, si
shl    edx, 3
add    edx, 4
imul    edx, eax
add    [bp-38], edx
.286
@6@146:
    inc    si
@6@170:
    cmp    si,word ptr [bp-18]
    jle    short @6@98
    inc    di
@6@218:
    cmp    di,word ptr [bp-14]
    jg    @@5
    jmp    @6@74
@@5:
    inc    word ptr [bp-6]
@6@266:
    mov    ax,word ptr [bp-6]
    cmp    ax,word ptr [bp-10]
    jg    @@6
    jmp    @6@50
@@6:
    ;
    ;          c2total += ((c2 << C_SHIFT) + ((1<<C_SHIFT)>>1)) * count;
    ;        }
   ;          }
   ;        }
   ;
   ;
;mov    eax, [bp-26]
;mov    edx, eax
;sar    edx, 1
    push    word ptr [bp-24]
    push    word ptr [bp-26]
    mov    ax,word ptr [bp-24]
    mov    dx,word ptr [bp-26]
    sar    ax,1
    rcr    dx,1
    mov    bx,word ptr [bp-28]
    mov    cx,word ptr [bp-30]
    add    cx,dx
    adc    bx,ax
    push    bx
    push    cx
    call    near ptr N_LDIV@
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx]
    add    bx,word ptr [bp+6]
    mov    byte ptr es:[bx],al
    ;
    ;      my_colormap[0][icolor] = (JSAMPLE) ((c0total + (total>>1)) / total);
    ;
    push    word ptr [bp-24]
    push    word ptr [bp-26]
    mov    ax,word ptr [bp-24]
    mov    dx,word ptr [bp-26]
    sar    ax,1
    rcr    dx,1
    mov    bx,word ptr [bp-32]
    mov    cx,word ptr [bp-34]
    add    cx,dx
    adc    bx,ax
    push    bx
    push    cx
    call    near ptr N_LDIV@
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx+4]
    add    bx,word ptr [bp+6]
    mov    byte ptr es:[bx],al
    ;
    ;      my_colormap[1][icolor] = (JSAMPLE) ((c1total + (total>>1)) / total);
    ;
    push    word ptr [bp-24]
    push    word ptr [bp-26]
    mov    ax,word ptr [bp-24]
    mov    dx,word ptr [bp-26]
    sar    ax,1
    rcr    dx,1
    mov    bx,word ptr [bp-36]
    mov    cx,word ptr [bp-38]
    add    cx,dx
    adc    bx,ax
    push    bx
    push    cx
    call    near ptr N_LDIV@
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx+8]
    add    bx,word ptr [bp+6]
    mov    byte ptr es:[bx],al
   ;
   ;      my_colormap[2][icolor] = (JSAMPLE) ((c2total + (total>>1)) / total);
   ;
    pop    di
    pop    si
    leave
    ret
compute_color    endp
   ;
   ;    LOCAL void
   ;
    assume    cs:_TEXT
remap_colormap    proc    near
    push    bp
    mov    bp,sp
    sub    sp,26
    push    si
    push    di
    mov    di,word ptr [bp+4]
   ;
   ;    remap_colormap (decompress_info_ptr cinfo)
   ;    /* Remap the internal colormap to the output colorspace */
   ;    {
   ;      /* This requires a little trickery since color_convert expects to
   ;       * deal with 3-D arrays (a 2-D sample array for each component).
   ;       * We must promote the colormaps into one-row 3-D arrays.
   ;       */
   ;      short ci;
   ;      JSAMPARRAY input_hack[3];
   ;      JSAMPARRAY output_hack[10];    /* assume no more than 10 output components */
   ;
   ;
    xor    si,si
    jmp    short @7@98
@7@50:
   ;
   ;      for (ci = 0; ci < 3; ci++)
   ;
    mov    bx,si
    shl    bx,1
    lea    ax,word ptr [bp-6]
    add    bx,ax
    mov    ax,si
    shl    ax,2
    mov    dx,word ptr DGROUP:my_colormap
    add    dx,ax
    mov    word ptr [bx],dx
    inc    si
@7@98:
    cmp    si,3
    jl    short @7@50
   ;
   ;        input_hack[ci] = &(my_colormap[ci]);
   ;
    xor    si,si
    jmp    short @7@194
@7@146:
   ;
   ;      for (ci = 0; ci < cinfo->color_out_comps; ci++)
   ;
    mov    ax,si
    shl    ax,2
    mov    dx,word ptr [di+145]
    add    dx,ax
    mov    bx,si
    shl    bx,1
    lea    ax,word ptr [bp-26]
    add    bx,ax
    mov    word ptr [bx],dx
    inc    si
@7@194:
    cmp    word ptr [di+139],si
    jg    short @7@146
   ;
   ;        output_hack[ci] = &(cinfo->colormap[ci]);
   ;
   ;
   ;
    ;      (*cinfo->methods->color_convert) (cinfo, 1,
   ;                        (long) cinfo->actual_number_of_colors,
   ;
    lea    ax,word ptr [bp-26]
    push    ax
    lea    ax,word ptr [bp-6]
    push    ax
    mov    ax,word ptr [di+143]
    cwd
    push    dx
    push    ax
    push    1
    push    di
    mov    bx,word ptr [di]
    call    word ptr [bx+44]
    add    sp,12
   ;
   ;                        input_hack, output_hack);
   ;
    pop    di
    pop    si
    leave
    ret
remap_colormap    endp
   ;
   ;    LOCAL void
   ;
    assume    cs:_TEXT
select_colors    proc    near
    push    bp
    mov    bp,sp
    dec    sp
    dec    sp
    push    si
    push    di
    mov    si,word ptr [bp+4]
   ;
   ;    select_colors (decompress_info_ptr cinfo)
   ;    /* Master routine for color selection */
   ;    {
   ;
    mov    ax,word ptr [si+24]
    mov    word ptr [bp-2],ax
   ;
    ;      int desired = cinfo->desired_number_of_colors;
   ;      int i;
   ;
   ;      /* Allocate workspace for box list */
   ;
    shl    ax,4
    push    ax
    mov    bx,word ptr [si+2]
    call    word ptr [bx+22]
    inc    sp
    inc    sp
    mov    word ptr DGROUP:boxlist,ax
   ;
   ;      boxlist = (boxptr) (*cinfo->emethods->alloc_small) (desired * SIZEOF(box));
    ;      /* Initialize one box containing whole space */
   ;
    mov    word ptr DGROUP:numboxes,1
   ;
   ;      numboxes = 1;
   ;
    mov    bx,word ptr DGROUP:boxlist
    mov    word ptr [bx],0
   ;
   ;      boxlist[0].c0min = 0;
   ;
    mov    bx,word ptr DGROUP:boxlist
    mov    word ptr [bx+2],63
   ;
   ;      boxlist[0].c0max = MAXJSAMPLE >> Y_SHIFT;
   ;
    mov    bx,word ptr DGROUP:boxlist
    mov    word ptr [bx+4],0
   ;
   ;      boxlist[0].c1min = 0;
   ;
    mov    bx,word ptr DGROUP:boxlist
    mov    word ptr [bx+6],31
   ;
   ;      boxlist[0].c1max = MAXJSAMPLE >> C_SHIFT;
   ;
    mov    bx,word ptr DGROUP:boxlist
    mov    word ptr [bx+8],0
   ;
   ;      boxlist[0].c2min = 0;
    ;
    mov    bx,word ptr DGROUP:boxlist
    mov    word ptr [bx+10],31
   ;
   ;      boxlist[0].c2max = MAXJSAMPLE >> C_SHIFT;
   ;      /* Shrink it to actually-used volume and set its statistics */
   ;
    push    word ptr DGROUP:boxlist
    call    near ptr update_box
    inc    sp
    inc    sp
   ;
   ;      update_box(& boxlist[0]);
   ;      /* Perform median-cut to produce final box list */
    ;
    push    word ptr [bp-2]
    call    near ptr median_cut
    inc    sp
    inc    sp
   ;
   ;      median_cut(desired);
   ;      /* Compute the representative color for each box, fill my_colormap[] */
   ;
    xor    di,di
    jmp    short @8@98
@8@50:
   ;
   ;      for (i = 0; i < numboxes; i++)
   ;
    push    di
    mov    ax,di
    shl    ax,4
    mov    dx,word ptr DGROUP:boxlist
    add    dx,ax
    push    dx
    call    near ptr compute_color
    add    sp,4
    inc    di
@8@98:
    cmp    di,word ptr DGROUP:numboxes
    jl    short @8@50
   ;
   ;        compute_color(& boxlist[i], i);
   ;
    mov    ax,word ptr DGROUP:numboxes
    mov    word ptr [si+143],ax
   ;
   ;      cinfo->actual_number_of_colors = numboxes;
   ;      /* Produce an output colormap in the desired output colorspace */
   ;
    push    si
    call    near ptr remap_colormap
    inc    sp
    inc    sp
   ;
   ;      remap_colormap(cinfo);
   ;      TRACEMS1(cinfo->emethods, 1, "Selected %d colors for quantization",
   ;
    mov    bx,word ptr [si+2]
    cmp    word ptr [bx+4],1
    jl    short @8@194
    mov    bx,word ptr [si+2]
    mov    ax,word ptr DGROUP:numboxes
    mov    word ptr [bx+6],ax
    push    offset DGROUP:s@
    mov    bx,word ptr [si+2]
    call    word ptr [bx+2]
    inc    sp
    inc    sp
@8@194:
   ;
   ;           numboxes);
   ;      /* Done with the box list */
   ;
    push    word ptr DGROUP:boxlist
    mov    bx,word ptr [si+2]
    call    word ptr [bx+24]
    inc    sp
    inc    sp
   ;
   ;      (*cinfo->emethods->free_small) ((void *) boxlist);
   ;
    pop    di
    pop    si
    leave
    ret
select_colors    endp
   ;
    ;    LOCAL int
   ;
    assume    cs:_TEXT
find_nearby_colors    proc    near
    push    bp
    mov    bp,sp
    sub    sp,1058
    push    si
    push    di
    mov    di,word ptr [bp+6]
   ;
   ;    find_nearby_colors (decompress_info_ptr cinfo, int minc0, int minc1, int minc2,
   ;                JSAMPLE colorlist[])
   ;    /* Locate the colormap entries close enough to an update box to be candidates
    ;     * for the nearest entry to some cell(s) in the update box.  The update box
   ;     * is specified by the center coordinates of its first cell.  The number of
   ;     * candidate colormap entries is returned, and their colormap indexes are
   ;     * placed in colorlist[].
   ;     * This routine uses Heckbert's "locally sorted search" criterion to select
   ;     * the colors that need further consideration.
   ;     */
   ;    {
   ;
    mov    bx,word ptr [bp+4]
    mov    ax,word ptr [bx+143]
    mov    word ptr [bp-2],ax
   ;
   ;      int numcolors = cinfo->actual_number_of_colors;
   ;      int maxc0, maxc1, maxc2;
   ;      int centerc0, centerc1, centerc2;
   ;      int i, x, ncolors;
   ;      INT32 minmaxdist, min_dist, max_dist, tdist;
   ;      INT32 mindist[MAXNUMCOLORS];    /* min distance to colormap entry i */
   ;
   ;      /* Compute true coordinates of update box's upper corner and center.
   ;       * Actually we compute the coordinates of the center of the upper-corner
   ;       * histogram cell, which are the upper bounds of the volume we care about.
   ;       * Note that since ">>" rounds down, the "center" values may be closer to
   ;       * min than to max; hence comparisons to them must be "<=", not "<".
   ;       */
   ;
    mov    ax,di
    add    ax,28
    mov    word ptr [bp-4],ax
    ;
   ;      maxc0 = minc0 + ((1 << BOX_Y_SHIFT) - (1 << Y_SHIFT));
   ;
    mov    ax,di
    add    ax,word ptr [bp-4]
    sar    ax,1
    mov    word ptr [bp-10],ax
   ;
   ;      centerc0 = (minc0 + maxc0) >> 1;
   ;
    mov    ax,word ptr [bp+8]
    add    ax,24
    mov    word ptr [bp-6],ax
   ;
    ;      maxc1 = minc1 + ((1 << BOX_C_SHIFT) - (1 << C_SHIFT));
   ;
    mov    ax,word ptr [bp+8]
    add    ax,word ptr [bp-6]
    sar    ax,1
    mov    word ptr [bp-12],ax
   ;
   ;      centerc1 = (minc1 + maxc1) >> 1;
   ;
    mov    ax,word ptr [bp+10]
    add    ax,24
    mov    word ptr [bp-8],ax
   ;
   ;      maxc2 = minc2 + ((1 << BOX_C_SHIFT) - (1 << C_SHIFT));
   ;
    mov    ax,word ptr [bp+10]
    add    ax,word ptr [bp-8]
    sar    ax,1
    mov    word ptr [bp-14],ax
   ;
   ;      centerc2 = (minc2 + maxc2) >> 1;
   ;
   ;      /* For each color in colormap, find:
   ;       *  1. its minimum squared-distance to any point in the update box
   ;       *     (zero if color is within update box);
   ;       *  2. its maximum squared-distance to any point in the update box.
   ;       * Both of these can be found by considering only the corners of the box.
   ;       * We save the minimum distance for each color in mindist[];
   ;       * only the smallest maximum distance is of interest.
   ;       * Note we have to scale Y to get correct distance in scaled space.
    ;       */
   ;
    mov    word ptr [bp-20],32767
    mov    word ptr [bp-22],65535
   ;
   ;      minmaxdist = 0x7FFFFFFFL;
   ;
   ;
    mov    word ptr [bp-16],0
    jmp    @9@746
@9@50:
   ;
   ;      for (i = 0; i < numcolors; i++) {
   ;        /* We compute the squared-c0-distance term, then add in the other two. */
    ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx]
    add    bx,word ptr [bp-16]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    mov    si,ax
   ;
   ;        x = GETJSAMPLE(my_colormap[0][i]);
   ;
    cmp    si,di
    jge    short @9@98
   ;
   ;        if (x < minc0) {
   ;
    sub    ax,di
    shl    ax,1
    cwd
    mov    word ptr [bp-32],dx
    mov    word ptr [bp-34],ax
   ;
   ;          tdist = (x - minc0) * Y_SCALE;
   ;
    mov    cx,word ptr [bp-32]
    mov    bx,word ptr [bp-34]
    mov    dx,word ptr [bp-32]
    call    near ptr N_LXMUL@
    mov    word ptr [bp-24],dx
    mov    word ptr [bp-26],ax
   ;
    ;          min_dist = tdist*tdist;
   ;
    mov    ax,si
    sub    ax,word ptr [bp-4]
    jmp    short @9@218
@9@98:
   ;
   ;          tdist = (x - maxc0) * Y_SCALE;
   ;          max_dist = tdist*tdist;
   ;
    cmp    si,word ptr [bp-4]
    jle    short @9@146
   ;
   ;        } else if (x > maxc0) {
    ;
    mov    ax,si
    sub    ax,word ptr [bp-4]
    shl    ax,1
    cwd
    mov    word ptr [bp-32],dx
    mov    word ptr [bp-34],ax
   ;
   ;          tdist = (x - maxc0) * Y_SCALE;
   ;
    mov    cx,word ptr [bp-32]
    mov    bx,word ptr [bp-34]
    mov    dx,word ptr [bp-32]
    call    near ptr N_LXMUL@
    mov    word ptr [bp-24],dx
    mov    word ptr [bp-26],ax
    jmp    short @9@194
@9@146:
   ;
   ;          min_dist = tdist*tdist;
   ;          tdist = (x - minc0) * Y_SCALE;
   ;          max_dist = tdist*tdist;
   ;        } else {
   ;          /* within cell range so no contribution to min_dist */
   ;
    mov    word ptr [bp-24],0
    mov    word ptr [bp-26],0
   ;
   ;          min_dist = 0;
   ;
    cmp    si,word ptr [bp-10]
    jg    short @9@194
   ;
   ;          if (x <= centerc0) {
   ;
    mov    ax,si
    sub    ax,word ptr [bp-4]
    jmp    short @9@218
@9@194:
    ;
    ;        tdist = (x - maxc0) * Y_SCALE;
    ;        max_dist = tdist*tdist;
    ;          } else {
    ;
    mov    ax,si
    sub    ax,di
@9@218:
    shl    ax,1
.386
movsx    edx, ax
mov    [bp-34], edx
    ;
    ;        tdist = (x - minc0) * Y_SCALE;
    ;
imul    edx, edx
mov    [bp-30], edx
.286
    ;
    ;        max_dist = tdist*tdist;
    ;          }
    ;        }
    ;
    ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx+4]
    add    bx,word ptr [bp-16]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    mov    si,ax
    ;
    ;        x = GETJSAMPLE(my_colormap[1][i]);
    ;
    cmp    si,word ptr [bp+8]
    jge    short @9@290
    ;
    ;        if (x < minc1) {
    ;
    sub    ax,word ptr [bp+8]
.386
movsx    edx, ax
mov    [bp-34], edx
    ;
    ;          tdist = x - minc1;
    ;
imul    edx, edx
add    [bp-26], edx
.286
    ;
    ;          min_dist += tdist*tdist;
    ;
    mov    ax,si
    sub    ax,word ptr [bp-6]
    jmp    short @9@410
@9@290:
    ;
    ;          tdist = x - maxc1;
    ;          max_dist += tdist*tdist;
    ;
    cmp    si,word ptr [bp-6]
    jle    short @9@338
    ;
    ;        } else if (x > maxc1) {
    ;
    mov    ax,si
    sub    ax,word ptr [bp-6]
.386
movsx    edx, ax
mov    [bp-34], edx
    ;
    ;          tdist = x - maxc1;
    ;
imul    edx, edx
add    [bp-36], edx
.286
    jmp    short @9@386
@9@338:
   ;
   ;          min_dist += tdist*tdist;
    ;          tdist = x - minc1;
   ;          max_dist += tdist*tdist;
   ;        } else {
   ;          /* within cell range so no contribution to min_dist */
   ;
    cmp    si,word ptr [bp-12]
    jg    short @9@386
   ;
   ;          if (x <= centerc1) {
   ;
    mov    ax,si
    sub    ax,word ptr [bp-6]
    jmp    short @9@410
@9@386:
   ;
   ;        tdist = x - maxc1;
   ;        max_dist += tdist*tdist;
   ;          } else {
   ;
    mov    ax,si
    sub    ax,word ptr [bp+8]
@9@410:
.386
movsx    edx, ax
mov    [bp-34], edx
    ;
    ;        tdist = x - minc1;
    ;
imul    edx, edx
add    [bp-30], edx
.286
    ;
    ;        max_dist += tdist*tdist;
    ;          }
    ;        }
    ;
    ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx+8]
    add    bx,word ptr [bp-16]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    mov    si,ax
    ;
    ;        x = GETJSAMPLE(my_colormap[2][i]);
    ;
    cmp    si,word ptr [bp+10]
    jge    short @9@482
    ;
    ;        if (x < minc2) {
    ;
    sub    ax,word ptr [bp+10]
.386
movsx    edx, ax
mov    [bp-34], edx
    ;
    ;          tdist = x - minc2;
    ;
imul    edx, edx
add    [bp-26], edx
.286
    ;
    ;          min_dist += tdist*tdist;
    ;
    mov    ax,si
    sub    ax,word ptr [bp-8]
    jmp    short @9@602
@9@482:
    ;
    ;          tdist = x - maxc2;
    ;          max_dist += tdist*tdist;
    ;
    cmp    si,word ptr [bp-8]
    jle    short @9@530
    ;
    ;        } else if (x > maxc2) {
    ;
    mov    ax,si
    sub    ax,word ptr [bp-8]
.386
movsx    edx, ax
mov    [bp-34], edx
    ;
    ;          tdist = x - maxc2;
    ;
imul    edx, edx
add    [bp-26], edx
.286
    jmp    short @9@578
@9@530:
    ;
    ;          min_dist += tdist*tdist;
    ;          tdist = x - minc2;
    ;          max_dist += tdist*tdist;
    ;        } else {
    ;          /* within cell range so no contribution to min_dist */
    ;
    cmp    si,word ptr [bp-14]
    jg    short @9@578
    ;
    ;          if (x <= centerc2) {
    ;
    mov    ax,si
    sub    ax,word ptr [bp-8]
    jmp    short @9@602
@9@578:
    ;
    ;        tdist = x - maxc2;
    ;        max_dist += tdist*tdist;
    ;          } else {
    ;
    mov    ax,si
    sub    ax,word ptr [bp+10]
@9@602:
.386
movsx    ecx, ax
mov    [bp-34], ecx
    ;
    ;        tdist = x - minc2;
    ;
imul    ecx, ecx
add    [bp-30], ecx
.286
    ;
    ;        max_dist += tdist*tdist;
    ;          }
    ;        }
    ;
    ;
    mov    bx,word ptr [bp-16]
    shl    bx,2
    lea    ax,word ptr [bp-1058]
    add    bx,ax
    mov    ax,word ptr [bp-24]
    mov    dx,word ptr [bp-26]
    mov    word ptr [bx+2],ax
    mov    word ptr [bx],dx
    ;
    ;        mindist[i] = min_dist;    /* save away the results */
    ;
    mov    ax,word ptr [bp-28]
    mov    dx,word ptr [bp-30]
    cmp    ax,word ptr [bp-20]
    jg    short @9@722
    jl    short @9@698
    cmp    dx,word ptr [bp-22]
    jae    short @9@722
@9@698:
   ;
   ;        if (max_dist < minmaxdist)
    ;
    mov    ax,word ptr [bp-28]
    mov    dx,word ptr [bp-30]
    mov    word ptr [bp-20],ax
    mov    word ptr [bp-22],dx
@9@722:
    inc    word ptr [bp-16]
@9@746:
    mov    ax,word ptr [bp-16]
    cmp    ax,word ptr [bp-2]
    jge    @@7
    jmp    @9@50
@@7:
   ;
   ;          minmaxdist = max_dist;
   ;      }
   ;
   ;      /* Now we know that no cell in the update box is more than minmaxdist
   ;       * away from some colormap entry.  Therefore, only colors that are
    ;       * within minmaxdist of some part of the box need be considered.
   ;       */
   ;
    mov    word ptr [bp-18],0
   ;
   ;      ncolors = 0;
   ;
    mov    word ptr [bp-16],0
    jmp    short @9@914
@9@794:
   ;
   ;      for (i = 0; i < numcolors; i++) {
   ;
    mov    bx,word ptr [bp-16]
    shl    bx,2
    lea    ax,word ptr [bp-1058]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    cmp    ax,word ptr [bp-20]
    jg    short @9@890
    jne    short @9@866
    cmp    dx,word ptr [bp-22]
    ja    short @9@890
@9@866:
    ;
   ;        if (mindist[i] <= minmaxdist)
   ;
    mov    bx,word ptr [bp+12]
    add    bx,word ptr [bp-18]
    mov    al,byte ptr [bp-16]
    mov    byte ptr [bx],al
    inc    word ptr [bp-18]
@9@890:
    inc    word ptr [bp-16]
@9@914:
    mov    ax,word ptr [bp-16]
    cmp    ax,word ptr [bp-2]
    jl    short @9@794
   ;
   ;          colorlist[ncolors++] = (JSAMPLE) i;
   ;      }
   ;
    mov    ax,word ptr [bp-18]
    ;
   ;      return ncolors;
   ;
    pop    di
    pop    si
    leave
    ret
find_nearby_colors    endp
   ;
    ;    LOCAL void
   ;
    assume    cs:_TEXT
find_best_colors    proc    near
    push    bp
    mov    bp,sp
    sub    sp,558
    push    si
    push    di
   ;
   ;    find_best_colors (decompress_info_ptr cinfo, int minc0, int minc1, int minc2,
   ;              int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])
   ;    /* Find the closest colormap entry for each cell in the update box,
   ;     * given the list of candidate colors prepared by find_nearby_colors.
   ;     * Return the indexes of the closest entries in the bestcolor[] array.
   ;     * This routine uses Thomas' incremental distance calculation method to
    ;     * find the distance from a colormap entry to successive cells in the box.
   ;     */
   ;    {
   ;      int ic0, ic1, ic2;
   ;      int i, icolor;
   ;      register INT32 * bptr;    /* pointer into bestdist[] array */
   ;      JSAMPLE * cptr;        /* pointer into bestcolor[] array */
   ;      INT32 dist0, dist1;        /* initial distance values */
   ;      register INT32 dist2;        /* current distance in inner loop */
   ;      INT32 xx0, xx1;        /* distance increments */
   ;      register INT32 xx2;
   ;      INT32 inc0, inc1, inc2;    /* initial values for increments */
   ;      /* This array holds the distance to the nearest-so-far color for each cell */
   ;      INT32 bestdist[BOX_Y_ELEMS * BOX_C_ELEMS * BOX_C_ELEMS];
   ;
   ;      /* Initialize best-distance for each cell of the update box */
   ;
    lea    ax,word ptr [bp-558]
    mov    si,ax
    ;
   ;      bptr = bestdist;
   ;
    mov    word ptr [bp-8],127
    jmp    short @10@98
@10@50:
   ;
   ;      for (i = BOX_Y_ELEMS*BOX_C_ELEMS*BOX_C_ELEMS-1; i >= 0; i--)
   ;
    mov    word ptr [si+2],32767
    mov    word ptr [si],65535
    add    si,4
    dec    word ptr [bp-8]
@10@98:
    cmp    word ptr [bp-8],0
    jge    short @10@50
   ;
    ;        *bptr++ = 0x7FFFFFFFL;
   ;
   ;      /* For each color selected by find_nearby_colors,
   ;       * compute its distance to the center of each cell in the box.
   ;       * If that's less than best-so-far, update best distance and color number.
   ;       * Note we have to scale Y to get correct distance in scaled space.
   ;       */
   ;
    ;      /* Nominal steps between cell centers ("x" in Thomas article) */
   ;    #define STEP_Y  ((1 << Y_SHIFT) * Y_SCALE)
   ;    #define STEP_C  (1 << C_SHIFT)
   ;
   ;
    mov    word ptr [bp-8],0
    jmp    @10@554
@10@146:
   ;
   ;      for (i = 0; i < numcolors; i++) {
   ;
    mov    bx,word ptr [bp+14]
    add    bx,word ptr [bp-8]
    mov    al,byte ptr [bx]
    mov    ah,0
    mov    word ptr [bp-10],ax
    ;
    ;        icolor = GETJSAMPLE(colorlist[i]);
    ;        /* Compute (square of) distance from minc0/c1/c2 to this color */
    ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx]
    add    bx,word ptr [bp-10]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    push    ax
    mov    ax,word ptr [bp+6]
    pop    dx
    sub    ax,dx
    shl    ax,1
.386
movsx    edx, ax
mov    [bp-38], edx
    ;
    ;        inc0 = (minc0 - (int) GETJSAMPLE(my_colormap[0][icolor])) * Y_SCALE;
    ;
imul    edx, edx
mov    [bp-14], edx
.286
    ;
    ;        dist0 = inc0*inc0;
    ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx+4]
    add    bx,word ptr [bp-10]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    push    ax
    mov    ax,word ptr [bp+8]
    pop    dx
    sub    ax,dx
.386
movsx    edx, ax
mov    [bp-42], edx
    ;
    ;        inc1 = minc1 - (int) GETJSAMPLE(my_colormap[1][icolor]);
    ;
imul    edx, edx
add    [bp-14], edx
.286
    ;
    ;        dist0 += inc1*inc1;
    ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx+8]
    add    bx,word ptr [bp-10]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    push    ax
    mov    ax,word ptr [bp+10]
    pop    dx
    sub    ax,dx
.386
movsx    edx, ax
mov    [bp-46], edx
    ;
    ;        inc2 = minc2 - (int) GETJSAMPLE(my_colormap[2][icolor]);
    ;
imul    edx, edx
add    [bp-14], edx
    ;
    ;        dist0 += inc2*inc2;
    ;        /* Form the initial difference increments */
    ;
mov    edx, [bp-38]
sal    edx, 4
add    edx, 64
mov    [bp-38], edx
    ;
    ;        inc0 = inc0 * (2 * STEP_Y) + STEP_Y * STEP_Y;
    ;
mov    eax, [bp-42]
sal    eax, 4
add    eax, 64
mov    [bp-42], eax
    ;
    ;        inc1 = inc1 * (2 * STEP_C) + STEP_C * STEP_C;
    ;
mov    edx, [bp-46]
sal    edx, 4
add    edx, 64
mov    [bp-46], edx
.286
    ;
    ;        inc2 = inc2 * (2 * STEP_C) + STEP_C * STEP_C;
    ;        /* Now loop over all cells in box, updating distance per Thomas method */
    ;
    lea    ax,word ptr [bp-558]
    mov    si,ax
    ;
    ;        bptr = bestdist;
    ;
    mov    di,word ptr [bp+16]
   ;
   ;        cptr = bestcolor;
   ;
    mov    ax,word ptr [bp-36]
    mov    dx,word ptr [bp-38]
    mov    word ptr [bp-24],ax
    mov    word ptr [bp-26],dx
   ;
   ;        xx0 = inc0;
   ;
    mov    word ptr [bp-2],7
    jmp    @10@506
@10@170:
   ;
   ;        for (ic0 = BOX_Y_ELEMS-1; ic0 >= 0; ic0--) {
    ;
    mov    ax,word ptr [bp-12]
    mov    dx,word ptr [bp-14]
    mov    word ptr [bp-16],ax
    mov    word ptr [bp-18],dx
    ;
    ;          dist1 = dist0;
    ;
    mov    ax,word ptr [bp-40]
    mov    dx,word ptr [bp-42]
    mov    word ptr [bp-28],ax
    mov    word ptr [bp-30],dx
   ;
   ;          xx1 = inc1;
   ;
    mov    word ptr [bp-4],3
    jmp    short @10@434
@10@194:
   ;
   ;          for (ic1 = BOX_C_ELEMS-1; ic1 >= 0; ic1--) {
   ;
    mov    ax,word ptr [bp-16]
    mov    dx,word ptr [bp-18]
    mov    word ptr [bp-20],ax
    mov    word ptr [bp-22],dx
   ;
    ;        dist2 = dist1;
   ;
    mov    ax,word ptr [bp-44]
    mov    dx,word ptr [bp-46]
    mov    word ptr [bp-32],ax
    mov    word ptr [bp-34],dx
   ;
   ;        xx2 = inc2;
   ;
    mov    word ptr [bp-6],3
    jmp    short @10@362
@10@218:
   ;
   ;        for (ic2 = BOX_C_ELEMS-1; ic2 >= 0; ic2--) {
   ;
    mov    ax,word ptr [si+2]
    mov    dx,word ptr [si]
    cmp    ax,word ptr [bp-20]
    jl    short @10@314
    jg    short @10@290
    cmp    dx,word ptr [bp-22]
    jbe    short @10@314
@10@290:
   ;
   ;          if (dist2 < *bptr) {
   ;
    mov    ax,word ptr [bp-20]
    mov    dx,word ptr [bp-22]
    mov    word ptr [si+2],ax
    mov    word ptr [si],dx
   ;
   ;            *bptr = dist2;
   ;
    mov    al,byte ptr [bp-10]
    mov    byte ptr [di],al
@10@314:
   ;
   ;            *cptr = (JSAMPLE) icolor;
   ;          }
   ;
    mov    ax,word ptr [bp-32]
    mov    dx,word ptr [bp-34]
    add    word ptr [bp-22],dx
    adc    word ptr [bp-20],ax
    ;
   ;          dist2 += xx2;
   ;
    add    word ptr [bp-34],128
    adc    word ptr [bp-32],0
   ;
   ;          xx2 += 2 * STEP_C * STEP_C;
   ;
    add    si,4
   ;
   ;          bptr++;
   ;
    inc    di
    dec    word ptr [bp-6]
@10@362:
    cmp    word ptr [bp-6],0
    jge    short @10@218
   ;
   ;          cptr++;
   ;        }
    ;
    mov    ax,word ptr [bp-28]
    mov    dx,word ptr [bp-30]
    add    word ptr [bp-18],dx
    adc    word ptr [bp-16],ax
   ;
   ;        dist1 += xx1;
   ;
    add    word ptr [bp-30],128
    adc    word ptr [bp-28],0
    dec    word ptr [bp-4]
@10@434:
    cmp    word ptr [bp-4],0
    jge    short @10@194
   ;
   ;        xx1 += 2 * STEP_C * STEP_C;
   ;          }
   ;
    mov    ax,word ptr [bp-24]
    mov    dx,word ptr [bp-26]
    add    word ptr [bp-14],dx
    adc    word ptr [bp-12],ax
   ;
   ;          dist0 += xx0;
    ;
    add    word ptr [bp-26],128
    adc    word ptr [bp-24],0
    dec    word ptr [bp-2]
@10@506:
    cmp    word ptr [bp-2],0
    jl    @@8
    jmp    @10@170
@@8:
    inc    word ptr [bp-8]
@10@554:
    mov    ax,word ptr [bp-8]
    cmp    ax,word ptr [bp+12]
    jge    @@9
    jmp    @10@146
@@9:
   ;
   ;          xx0 += 2 * STEP_Y * STEP_Y;
   ;        }
   ;      }
    ;
    pop    di
    pop    si
    leave
    ret
find_best_colors    endp
   ;
   ;    LOCAL void
   ;
    assume    cs:_TEXT
fill_inverse_cmap    proc    near
    push    bp
    mov    bp,sp
    sub    sp,400
    push    si
    push    di
   ;
   ;    fill_inverse_cmap (decompress_info_ptr cinfo, int c0, int c1, int c2)
   ;    /* Fill the inverse-colormap entries in the update box that contains */
   ;    /* histogram cell c0/c1/c2.  (Only that one cell MUST be filled, but */
   ;    /* we can fill as many others as we wish.) */
   ;    {
   ;      int minc0, minc1, minc2;    /* lower left corner of update box */
   ;      int ic0, ic1, ic2;
    ;      register JSAMPLE * cptr;    /* pointer into bestcolor[] array */
   ;      register histptr cachep;    /* pointer into main cache array */
   ;      /* This array lists the candidate colormap indexes. */
   ;      JSAMPLE colorlist[MAXNUMCOLORS];
   ;      int numcolors;        /* number of candidate colors */
   ;      /* This array holds the actually closest colormap index for each cell. */
   ;      JSAMPLE bestcolor[BOX_Y_ELEMS * BOX_C_ELEMS * BOX_C_ELEMS];
   ;
   ;      /* Convert cell coordinates to update box ID */
   ;
    sar    word ptr [bp+6],3
   ;
   ;      c0 >>= BOX_Y_LOG;
   ;
    sar    word ptr [bp+8],2
   ;
   ;      c1 >>= BOX_C_LOG;
   ;
    sar    word ptr [bp+10],2
   ;
    ;      c2 >>= BOX_C_LOG;
   ;
    ;      /* Compute true coordinates of update box's origin corner.
   ;       * Actually we compute the coordinates of the center of the corner
   ;       * histogram cell, which are the lower bounds of the volume we care about.
   ;       */
   ;
    mov    ax,word ptr [bp+6]
    shl    ax,5
    inc    ax
    inc    ax
    mov    word ptr [bp-2],ax
   ;
   ;      minc0 = (c0 << BOX_Y_SHIFT) + ((1 << Y_SHIFT) >> 1);
   ;
    mov    ax,word ptr [bp+8]
    shl    ax,5
    add    ax,4
    mov    word ptr [bp-4],ax
   ;
   ;      minc1 = (c1 << BOX_C_SHIFT) + ((1 << C_SHIFT) >> 1);
   ;
    mov    ax,word ptr [bp+10]
    shl    ax,5
    add    ax,4
    mov    word ptr [bp-6],ax
   ;
   ;      minc2 = (c2 << BOX_C_SHIFT) + ((1 << C_SHIFT) >> 1);
   ;
   ;      /* Determine which colormap entries are close enough to be candidates
   ;       * for the nearest entry to some cell in the update box.
   ;       */
   ;
    lea    ax,word ptr [bp-272]
    push    ax
    push    word ptr [bp-6]
    push    word ptr [bp-4]
    push    word ptr [bp-2]
    push    word ptr [bp+4]
    call    near ptr find_nearby_colors
    add    sp,10
    mov    word ptr [bp-16],ax
   ;
   ;      numcolors = find_nearby_colors(cinfo, minc0, minc1, minc2, colorlist);
    ;
   ;      /* Determine the actually nearest colors. */
    ;
   ;
   ;      find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist,
   ;
    lea    ax,word ptr [bp-400]
    push    ax
    lea    ax,word ptr [bp-272]
    push    ax
    push    word ptr [bp-16]
    push    word ptr [bp-6]
    push    word ptr [bp-4]
    push    word ptr [bp-2]
    push    word ptr [bp+4]
    call    near ptr find_best_colors
    add    sp,14
   ;
   ;               bestcolor);
   ;
   ;      /* Save the best color numbers (plus 1) in the main cache array */
   ;
    shl    word ptr [bp+6],3
   ;
    ;      c0 <<= BOX_Y_LOG;        /* convert ID back to base cell indexes */
   ;
    shl    word ptr [bp+8],2
   ;
   ;      c1 <<= BOX_C_LOG;
   ;
    shl    word ptr [bp+10],2
   ;
   ;      c2 <<= BOX_C_LOG;
   ;
    lea    ax,word ptr [bp-400]
    mov    si,ax
   ;
   ;      cptr = bestcolor;
   ;
    mov    word ptr [bp-8],0
    jmp    short @11@242
@11@50:
   ;
   ;      for (ic0 = 0; ic0 < BOX_Y_ELEMS; ic0++) {
    ;
    mov    word ptr [bp-10],0
    jmp    short @11@194
@11@74:
   ;
   ;        for (ic1 = 0; ic1 < BOX_C_ELEMS; ic1++) {
   ;
    mov    ax,word ptr [bp+6]
    add    ax,word ptr [bp-8]
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,word ptr [bp+8]
    add    bx,word ptr [bp-10]
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp+10]
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-12],ax
    mov    word ptr [bp-14],dx
   ;
    ;          cachep = & histogram[c0+ic0][c1+ic1][c2];
   ;
    xor    di,di
    jmp    short @11@146
@11@98:
   ;
   ;          for (ic2 = 0; ic2 < BOX_C_ELEMS; ic2++) {
   ;
    mov    al,byte ptr [si]
    mov    ah,0
    inc    ax
    les    bx,dword ptr [bp-14]
    mov    word ptr es:[bx],ax
    inc    si
    add    word ptr [bp-14],2
    inc    di
@11@146:
    cmp    di,4
    jl    short @11@98
    inc    word ptr [bp-10]
@11@194:
    cmp    word ptr [bp-10],4
    jl    short @11@74
    inc    word ptr [bp-8]
@11@242:
    cmp    word ptr [bp-8],8
    jl    short @11@50
   ;
   ;        *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1);
   ;          }
   ;        }
   ;      }
   ;
    pop    di
    pop    si
    leave
    ret
fill_inverse_cmap    endp
   ;
   ;    METHODDEF void
   ;
    assume    cs:_TEXT
pass2_nodither    proc    near
    push    bp
    mov    bp,sp
    sub    sp,32
    push    si
    push    di
   ;
   ;    pass2_nodither (decompress_info_ptr cinfo, int num_rows,
   ;            JSAMPIMAGE image_data, JSAMPARRAY output_workspace)
   ;    /* This version performs no dithering */
   ;    {
   ;      register JSAMPROW ptr0, ptr1, ptr2, outptr;
   ;      register histptr cachep;
   ;      register int c0, c1, c2;
   ;      int row;
   ;      long col;
   ;
    mov    bx,word ptr [bp+4]
    mov    ax,word ptr [bx+38]
    mov    dx,word ptr [bx+36]
    mov    word ptr [bp-30],ax
    mov    word ptr [bp-32],dx
    ;
   ;      long width = cinfo->image_width;
    ;
   ;      /* Convert data to colormap indexes, which we save in output_workspace */
   ;
    mov    word ptr [bp-24],0
    jmp    @12@266
@12@50:
   ;
   ;      for (row = 0; row < num_rows; row++) {
   ;
    mov    ax,word ptr [bp-24]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;        ptr0 = image_data[0][row];
   ;
    mov    ax,word ptr [bp-24]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx+2]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-6],ax
    mov    word ptr [bp-8],dx
   ;
   ;        ptr1 = image_data[1][row];
   ;
    mov    ax,word ptr [bp-24]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx+4]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-10],ax
    mov    word ptr [bp-12],dx
    ;
   ;        ptr2 = image_data[2][row];
    ;
    mov    ax,word ptr [bp-24]
    shl    ax,2
    mov    bx,word ptr [bp+10]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-14],ax
    mov    word ptr [bp-16],dx
   ;
   ;        outptr = output_workspace[row];
   ;
    mov    ax,word ptr [bp-30]
    mov    dx,word ptr [bp-32]
    mov    word ptr [bp-26],ax
    mov    word ptr [bp-28],dx
    jmp    @12@170
@12@74:
   ;
   ;        for (col = width; col > 0; col--) {
   ;          /* get pixel value and index into the cache */
   ;
    les    bx,dword ptr [bp-4]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sar    ax,2
    mov    si,ax
    inc    word ptr [bp-4]
   ;
   ;          c0 = GETJSAMPLE(*ptr0++) >> Y_SHIFT;
   ;
    les    bx,dword ptr [bp-8]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sar    ax,3
    mov    di,ax
    inc    word ptr [bp-8]
   ;
   ;          c1 = GETJSAMPLE(*ptr1++) >> C_SHIFT;
   ;
    les    bx,dword ptr [bp-12]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sar    ax,3
    mov    word ptr [bp-22],ax
    inc    word ptr [bp-12]
   ;
   ;          c2 = GETJSAMPLE(*ptr2++) >> C_SHIFT;
   ;
    mov    ax,si
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,di
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp-22]
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-18],ax
    mov    word ptr [bp-20],dx
   ;
   ;          cachep = & histogram[c0][c1][c2];
   ;          /* If we have not seen this color before, find nearest colormap entry */
    ;          /* and update the cache */
   ;
    les    bx,dword ptr [bp-20]
    cmp    word ptr es:[bx],0
    jne    short @12@122
   ;
   ;          if (*cachep == 0)
   ;
    push    word ptr [bp-22]
    push    di
    push    si
    push    word ptr [bp+4]
    call    near ptr fill_inverse_cmap
    add    sp,8
@12@122:
   ;
   ;        fill_inverse_cmap(cinfo, c0,c1,c2);
   ;          /* Now emit the colormap index for this cell */
   ;
    les    bx,dword ptr [bp-20]
    mov    al,byte ptr es:[bx]
    dec    al
    les    bx,dword ptr [bp-16]
    mov    byte ptr es:[bx],al
    inc    word ptr [bp-16]
    sub    word ptr [bp-28],1
    sbb    word ptr [bp-26],0
@12@170:
    cmp    word ptr [bp-26],0
    jle    @@10
    jmp    @12@74
@@10:
    jne    short @12@242
    cmp    word ptr [bp-28],0
    jbe    @@11
    jmp    @12@74
@@11:
@12@242:
    inc    word ptr [bp-24]
@12@266:
    mov    ax,word ptr [bp-24]
    cmp    ax,word ptr [bp+6]
    jge    @@12
    jmp    @12@50
@@12:
   ;
   ;          *outptr++ = (JSAMPLE) (*cachep - 1);
   ;        }
   ;      }
   ;      /* Emit converted rows to the output file */
   ;
    lea    ax,word ptr [bp+10]
    push    ax
    push    word ptr [bp+6]
    push    word ptr [bp+4]
    mov    bx,word ptr [bp+4]
    mov    bx,word ptr [bx]
    call    word ptr [bx+62]
    add    sp,6
   ;
   ;      (*cinfo->methods->put_pixel_rows) (cinfo, num_rows, &output_workspace);
   ;
    pop    di
    pop    si
    leave
    ret
pass2_nodither    endp
   ;
   ;    METHODDEF void
   ;
    assume    cs:_TEXT
pass2_dither    proc    near
    push    bp
    mov    bp,sp
    sub    sp,46
    push    si
    push    di
   ;
   ;    pass2_dither (decompress_info_ptr cinfo, int num_rows,
   ;              JSAMPIMAGE image_data, JSAMPARRAY output_workspace)
   ;    /* This version performs Floyd-Steinberg dithering */
   ;    {
   ;      register FSERROR val;
   ;      register FSERRPTR thisrowerr, nextrowerr;
   ;      register FSERROR c0, c1, c2;
   ;      register int pixcode;
   ;      JSAMPROW ptr0, ptr1, ptr2, outptr;
   ;      histptr cachep;
    ;      int dir;
   ;      long col;
   ;      int row;
   ;
    mov    bx,word ptr [bp+4]
    mov    ax,word ptr [bx+38]
    mov    dx,word ptr [bx+36]
    mov    word ptr [bp-44],ax
    mov    word ptr [bp-46],dx
   ;
   ;      long width = cinfo->image_width;
   ;
   ;      /* Convert data to colormap indexes, which we save in output_workspace */
   ;
    mov    word ptr [bp-42],0
    jmp    @13@626
@13@50:
   ;
   ;      for (row = 0; row < num_rows; row++) {
   ;
    mov    ax,word ptr [bp-42]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-16],ax
    mov    word ptr [bp-18],dx
   ;
   ;        ptr0 = image_data[0][row];
   ;
    mov    ax,word ptr [bp-42]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx+2]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-20],ax
    mov    word ptr [bp-22],dx
   ;
   ;        ptr1 = image_data[1][row];
   ;
    mov    ax,word ptr [bp-42]
    shl    ax,2
    mov    bx,word ptr [bp+8]
    mov    bx,word ptr [bx+4]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-24],ax
    mov    word ptr [bp-26],dx
   ;
   ;        ptr2 = image_data[2][row];
   ;
    mov    ax,word ptr [bp-42]
    shl    ax,2
    mov    bx,word ptr [bp+10]
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    word ptr [bp-28],ax
    mov    word ptr [bp-30],dx
    ;
   ;        outptr = output_workspace[row];
    ;
    cmp    word ptr DGROUP:on_odd_row,0
    je    short @13@98
   ;
   ;        if (on_odd_row) {
   ;          /* work right to left in this row */
   ;
    mov    ax,word ptr [bp-46]
    dec    ax
    add    word ptr [bp-18],ax
   ;
   ;          ptr0 += width - 1;
   ;
    mov    ax,word ptr [bp-46]
    dec    ax
    add    word ptr [bp-22],ax
   ;
   ;          ptr1 += width - 1;
   ;
    mov    ax,word ptr [bp-46]
    dec    ax
    add    word ptr [bp-26],ax
    ;
   ;          ptr2 += width - 1;
   ;
    mov    ax,word ptr [bp-46]
    dec    ax
    add    word ptr [bp-30],ax
   ;
   ;          outptr += width - 1;
   ;
    mov    word ptr [bp-36],65535
   ;
   ;          dir = -1;
   ;
    mov    ax,word ptr DGROUP:oddrowerrs+2
    mov    dx,word ptr DGROUP:oddrowerrs
    add    dx,6
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;          thisrowerr = oddrowerrs + 3;
    ;
    mov    cx,word ptr [bp-44]
    mov    bx,word ptr [bp-46]
    xor    dx,dx
    mov    ax,3
    call    near ptr N_LXMUL@
    shl    ax,1
    mov    dx,word ptr DGROUP:evenrowerrs+2
    mov    bx,word ptr DGROUP:evenrowerrs
    add    bx,ax
    mov    word ptr [bp-6],dx
    mov    word ptr [bp-8],bx
   ;
   ;          nextrowerr = evenrowerrs + width*3;
   ;
    mov    word ptr DGROUP:on_odd_row,0
   ;
   ;          on_odd_row = FALSE;    /* flip for next time */
   ;
    jmp    short @13@122
@13@98:
   ;
   ;        } else {
   ;          /* work left to right in this row */
    ;
    mov    word ptr [bp-36],1
   ;
   ;          dir = 1;
   ;
    mov    ax,word ptr DGROUP:evenrowerrs+2
    mov    dx,word ptr DGROUP:evenrowerrs
    add    dx,6
    mov    word ptr [bp-2],ax
    mov    word ptr [bp-4],dx
   ;
   ;          thisrowerr = evenrowerrs + 3;
   ;
    mov    cx,word ptr [bp-44]
    mov    bx,word ptr [bp-46]
    xor    dx,dx
    mov    ax,3
    call    near ptr N_LXMUL@
    shl    ax,1
    mov    dx,word ptr DGROUP:oddrowerrs+2
    mov    bx,word ptr DGROUP:oddrowerrs
    add    bx,ax
    mov    word ptr [bp-6],dx
    mov    word ptr [bp-8],bx
   ;
   ;          nextrowerr = oddrowerrs + width*3;
   ;
    mov    word ptr DGROUP:on_odd_row,1
@13@122:
   ;
   ;          on_odd_row = TRUE;    /* flip for next time */
   ;        }
   ;        /* need only initialize this one entry in nextrowerr */
   ;
    les    bx,dword ptr [bp-8]
    xor    ax,ax
    mov    word ptr es:[bx+4],ax
    mov    word ptr es:[bx+2],ax
    mov    word ptr es:[bx],ax
   ;
   ;        nextrowerr[0] = nextrowerr[1] = nextrowerr[2] = 0;
   ;
    mov    ax,word ptr [bp-44]
    mov    dx,word ptr [bp-46]
    mov    word ptr [bp-38],ax
    mov    word ptr [bp-40],dx
    jmp    @13@530
@13@146:
   ;
   ;        for (col = width; col > 0; col--) {
   ;          /* Get this pixel's value and add accumulated errors */
   ;          /* The errors are in units of 1/16th pixel value */
   ;
    les    bx,dword ptr [bp-18]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    shl    ax,4
    les    bx,dword ptr [bp-4]
    add    ax,word ptr es:[bx]
    mov    si,ax
   ;
   ;          val = (GETJSAMPLE(*ptr0) << 4) + thisrowerr[0];
   ;
    or    si,si
    jg    short @13@194
    xor    si,si
    jmp    short @13@242
@13@194:
   ;
   ;          if (val <= 0) val = 0;    /* must watch for range overflow! */
   ;          else {
   ;
    add    si,8
   ;
   ;        val += 8;        /* divide by 16 with proper rounding */
   ;
    sar    si,4
   ;
   ;        val >>= 4;
   ;
    cmp    si,255
    jle    short @13@242
    mov    si,255
@13@242:
   ;
   ;        if (val > MAXJSAMPLE) val = MAXJSAMPLE;
   ;          }
   ;
    mov    di,si
   ;
   ;          c0 = val;
   ;
    les    bx,dword ptr [bp-22]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    shl    ax,4
    les    bx,dword ptr [bp-4]
    add    ax,word ptr es:[bx+2]
    mov    si,ax
   ;
   ;          val = (GETJSAMPLE(*ptr1) << 4) + thisrowerr[1];
   ;
    or    si,si
    jg    short @13@290
    xor    si,si
    jmp    short @13@338
@13@290:
   ;
    ;          if (val <= 0) val = 0;    /* must watch for range overflow! */
   ;          else {
   ;
    add    si,8
   ;
   ;        val += 8;        /* divide by 16 with proper rounding */
   ;
    sar    si,4
   ;
   ;        val >>= 4;
   ;
    cmp    si,255
    jle    short @13@338
    mov    si,255
@13@338:
   ;
   ;        if (val > MAXJSAMPLE) val = MAXJSAMPLE;
   ;          }
   ;
    mov    word ptr [bp-10],si
   ;
   ;          c1 = val;
   ;
    les    bx,dword ptr [bp-26]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    shl    ax,4
    les    bx,dword ptr [bp-4]
    add    ax,word ptr es:[bx+4]
    mov    si,ax
   ;
   ;          val = (GETJSAMPLE(*ptr2) << 4) + thisrowerr[2];
   ;
    or    si,si
    jg    short @13@386
    xor    si,si
    jmp    short @13@434
@13@386:
   ;
   ;          if (val <= 0) val = 0;    /* must watch for range overflow! */
   ;          else {
   ;
    add    si,8
   ;
    ;        val += 8;        /* divide by 16 with proper rounding */
   ;
    sar    si,4
   ;
   ;        val >>= 4;
   ;
    cmp    si,255
    jle    short @13@434
    mov    si,255
@13@434:
   ;
   ;        if (val > MAXJSAMPLE) val = MAXJSAMPLE;
   ;          }
   ;
    mov    word ptr [bp-12],si
   ;
   ;          c2 = val;
   ;          /* Index into the cache with adjusted value */
   ;
    mov    ax,di
    sar    ax,2
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    mov    ax,word ptr [bx+2]
    mov    dx,word ptr [bx]
    mov    bx,word ptr [bp-10]
    sar    bx,3
    shl    bx,6
    add    dx,bx
    mov    bx,word ptr [bp-12]
    sar    bx,3
    shl    bx,1
    add    dx,bx
    mov    word ptr [bp-32],ax
    mov    word ptr [bp-34],dx
   ;
   ;          cachep = & histogram[c0 >> Y_SHIFT][c1 >> C_SHIFT][c2 >> C_SHIFT];
   ;          /* If we have not seen this color before, find nearest colormap */
   ;          /* entry and update the cache */
   ;
    les    bx,dword ptr [bp-34]
    cmp    word ptr es:[bx],0
    jne    short @13@482
    ;
   ;          if (*cachep == 0)
   ;
    mov    ax,word ptr [bp-12]
    sar    ax,3
    push    ax
    mov    ax,word ptr [bp-10]
    sar    ax,3
    push    ax
    mov    ax,di
    sar    ax,2
    push    ax
    push    word ptr [bp+4]
    call    near ptr fill_inverse_cmap
    add    sp,8
@13@482:
   ;
   ;        fill_inverse_cmap(cinfo, c0 >> Y_SHIFT, c1 >> C_SHIFT, c2 >> C_SHIFT);
   ;          /* Now emit the colormap index for this cell */
   ;
    les    bx,dword ptr [bp-34]
    mov    ax,word ptr es:[bx]
    dec    ax
    mov    word ptr [bp-14],ax
    ;
   ;          pixcode = *cachep - 1;
   ;
    les    bx,dword ptr [bp-30]
    mov    al,byte ptr [bp-14]
    mov    byte ptr es:[bx],al
   ;
   ;          *outptr = (JSAMPLE) pixcode;
   ;          /* Compute representation error for this pixel */
   ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx]
    add    bx,word ptr [bp-14]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sub    di,ax
   ;
   ;          c0 -= (FSERROR) GETJSAMPLE(my_colormap[0][pixcode]);
   ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx+4]
    add    bx,word ptr [bp-14]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sub    word ptr [bp-10],ax
   ;
   ;          c1 -= (FSERROR) GETJSAMPLE(my_colormap[1][pixcode]);
   ;
    mov    bx,word ptr DGROUP:my_colormap
    les    bx,dword ptr [bx+8]
    add    bx,word ptr [bp-14]
    mov    al,byte ptr es:[bx]
    mov    ah,0
    sub    word ptr [bp-12],ax
   ;
   ;          c2 -= (FSERROR) GETJSAMPLE(my_colormap[2][pixcode]);
   ;          /* Propagate error to adjacent pixels */
   ;          /* Remember that nextrowerr entries are in reverse order! */
   ;
    mov    ax,di
    shl    ax,1
    mov    si,ax
   ;
   ;          val = c0 * 2;
    ;
    les    bx,dword ptr [bp-8]
    mov    word ptr es:[bx-6],di
   ;
   ;          nextrowerr[0-3]  = c0;    /* not +=, since not initialized yet */
   ;
    add    di,si
   ;
   ;          c0 += val;        /* form error * 3 */
   ;
    add    word ptr es:[bx+6],di
   ;
   ;          nextrowerr[0+3] += c0;
   ;
    add    di,si
   ;
   ;          c0 += val;        /* form error * 5 */
   ;
    add    word ptr es:[bx],di
   ;
    ;          nextrowerr[0  ] += c0;
   ;
    add    di,si
   ;
   ;          c0 += val;        /* form error * 7 */
   ;
    les    bx,dword ptr [bp-4]
    add    word ptr es:[bx+6],di
   ;
   ;          thisrowerr[0+3] += c0;
   ;
    mov    ax,word ptr [bp-10]
    shl    ax,1
    mov    si,ax
   ;
   ;          val = c1 * 2;
   ;
    les    bx,dword ptr [bp-8]
    mov    ax,word ptr [bp-10]
    mov    word ptr es:[bx-4],ax
   ;
   ;          nextrowerr[1-3]  = c1;    /* not +=, since not initialized yet */
   ;
    add    word ptr [bp-10],si
    ;
   ;          c1 += val;        /* form error * 3 */
   ;
    mov    ax,word ptr [bp-10]
    add    word ptr es:[bx+8],ax
   ;
   ;          nextrowerr[1+3] += c1;
   ;
    add    word ptr [bp-10],si
   ;
   ;          c1 += val;        /* form error * 5 */
   ;
    mov    ax,word ptr [bp-10]
    add    word ptr es:[bx+2],ax
   ;
   ;          nextrowerr[1  ] += c1;
   ;
    add    word ptr [bp-10],si
   ;
   ;          c1 += val;        /* form error * 7 */
    ;
    les    bx,dword ptr [bp-4]
    mov    ax,word ptr [bp-10]
    add    word ptr es:[bx+8],ax
   ;
   ;          thisrowerr[1+3] += c1;
   ;
    mov    ax,word ptr [bp-12]
    shl    ax,1
    mov    si,ax
   ;
   ;          val = c2 * 2;
   ;
    les    bx,dword ptr [bp-8]
    mov    ax,word ptr [bp-12]
    mov    word ptr es:[bx-2],ax
   ;
   ;          nextrowerr[2-3]  = c2;    /* not +=, since not initialized yet */
   ;
    add    word ptr [bp-12],si
   ;
   ;          c2 += val;        /* form error * 3 */
   ;
    mov    ax,word ptr [bp-12]
    add    word ptr es:[bx+10],ax
   ;
   ;          nextrowerr[2+3] += c2;
   ;
    add    word ptr [bp-12],si
   ;
   ;          c2 += val;        /* form error * 5 */
   ;
    mov    ax,word ptr [bp-12]
    add    word ptr es:[bx+4],ax
   ;
   ;          nextrowerr[2  ] += c2;
   ;
    add    word ptr [bp-12],si
   ;
   ;          c2 += val;        /* form error * 7 */
   ;
    les    bx,dword ptr [bp-4]
    mov    ax,word ptr [bp-12]
    add    word ptr es:[bx+10],ax
    ;
   ;          thisrowerr[2+3] += c2;
   ;          /* Advance to next column */
   ;
    mov    ax,word ptr [bp-36]
    add    word ptr [bp-18],ax
   ;
   ;          ptr0 += dir;
   ;
    add    word ptr [bp-22],ax
   ;
   ;          ptr1 += dir;
   ;
    add    word ptr [bp-26],ax
   ;
   ;          ptr2 += dir;
   ;
    add    word ptr [bp-30],ax
   ;
   ;          outptr += dir;
   ;
    add    word ptr [bp-4],6
   ;
   ;          thisrowerr += 3;        /* cur-row error ptr advances to right */
    ;
    sub    word ptr [bp-8],6
    sub    word ptr [bp-40],1
    sbb    word ptr [bp-38],0
@13@530:
    cmp    word ptr [bp-38],0
    jle    @@13
    jmp    @13@146
@@13:
    jne    short @13@602
    cmp    word ptr [bp-40],0
    jbe    @@14
    jmp    @13@146
@@14:
@13@602:
    inc    word ptr [bp-42]
@13@626:
    mov    ax,word ptr [bp-42]
    cmp    ax,word ptr [bp+6]
    jge    @@15
    jmp    @13@50
@@15:
   ;
   ;          nextrowerr -= 3;        /* next-row error ptr advances to left */
   ;        }
   ;      }
   ;      /* Emit converted rows to the output file */
   ;
    lea    ax,word ptr [bp+10]
    push    ax
    push    word ptr [bp+6]
    push    word ptr [bp+4]
    mov    bx,word ptr [bp+4]
    mov    bx,word ptr [bx]
    call    word ptr [bx+62]
    add    sp,6
   ;
   ;      (*cinfo->methods->put_pixel_rows) (cinfo, num_rows, &output_workspace);
   ;
    pop    di
    pop    si
    leave
    ret
pass2_dither    endp
    ;
   ;    METHODDEF void
   ;
    assume    cs:_TEXT
color_quant_init    proc    near
    push    bp
    mov    bp,sp
    dec    sp
    dec    sp
    push    si
    push    di
    mov    si,word ptr [bp+4]
   ;
   ;    color_quant_init (decompress_info_ptr cinfo)
   ;    {
   ;      int i;
   ;
   ;      /* Lower bound on # of colors ... somewhat arbitrary as long as > 0 */
   ;
    cmp    word ptr [si+24],8
    jge    short @14@74
   ;
   ;      if (cinfo->desired_number_of_colors < 8)
   ;
    push    offset DGROUP:s@+36
    mov    bx,word ptr [si+2]
    call    word ptr [bx]
    inc    sp
    inc    sp
@14@74:
   ;
   ;        ERREXIT(cinfo->emethods, "Cannot request less than 8 quantized colors");
   ;      /* Make sure colormap indexes can be represented by JSAMPLEs */
   ;
    cmp    word ptr [si+24],256
    jle    short @14@122
   ;
   ;      if (cinfo->desired_number_of_colors > MAXNUMCOLORS)
   ;        ERREXIT1(cinfo->emethods, "Cannot request more than %d quantized colors",
   ;
    mov    bx,word ptr [si+2]
    mov    word ptr [bx+6],256
    push    offset DGROUP:s@+80
    mov    bx,word ptr [si+2]
    call    word ptr [bx]
    inc    sp
    inc    sp
@14@122:
   ;
   ;             MAXNUMCOLORS);
   ;
   ;      /* Allocate and zero the histogram */
   ;
   ;
   ;      histogram = (hist3d) (*cinfo->emethods->alloc_small)
   ;
    push    256
    mov    bx,word ptr [si+2]
    call    word ptr [bx+22]
    inc    sp
    inc    sp
    mov    word ptr DGROUP:histogram,ax
   ;
   ;                    (HIST_Y_ELEMS * SIZEOF(hist2d));
    ;
    xor    di,di
    jmp    short @14@194
@14@146:
   ;
   ;      for (i = 0; i < HIST_Y_ELEMS; i++) {
   ;
   ;
   ;        histogram[i] = (hist2d) (*cinfo->emethods->alloc_medium)
   ;
    push    2048
    mov    bx,word ptr [si+2]
    call    word ptr [bx+26]
    inc    sp
    inc    sp
    mov    bx,di
    shl    bx,2
    push    ax
    push    dx
    push    bx
    mov    bx,word ptr DGROUP:histogram
    pop    ax
    add    bx,ax
    pop    ax
    mov    word ptr [bx+2],ax
    pop    ax
    mov    word ptr [bx],ax
   ;
   ;                    (HIST_C_ELEMS*HIST_C_ELEMS * SIZEOF(histcell));
   ;
   ;
   ;        jzero_far((void FAR *) histogram[i],
   ;
    push    2048
    mov    ax,di
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    push    word ptr [bx+2]
    push    word ptr [bx]
    call    near ptr _jzero_far
    add    sp,6
    inc    di
@14@194:
    cmp    di,64
    jl    short @14@146
   ;
   ;              HIST_C_ELEMS*HIST_C_ELEMS * SIZEOF(histcell));
   ;      }
   ;
   ;      /* Allocate storage for the internal and external colormaps. */
   ;      /* We do this now since it is FAR storage and may affect the memory */
   ;      /* manager's space calculations. */
   ;
   ;
   ;      my_colormap = (*cinfo->emethods->alloc_small_sarray)
   ;                ((long) cinfo->desired_number_of_colors,
   ;
    push    0
    push    3
    mov    ax,word ptr [si+24]
    cwd
    push    dx
    push    ax
    mov    bx,word ptr [si+2]
    call    word ptr [bx+30]
    add    sp,8
    mov    word ptr DGROUP:my_colormap,ax
    ;
    ;                 (long) 3);
    ;
    ;
    ;      cinfo->colormap = (*cinfo->emethods->alloc_small_sarray)
    ;                ((long) cinfo->desired_number_of_colors,
    ;
    mov    ax,word ptr [si+139]
    cwd
    push    dx
    push    ax
    mov    ax,word ptr [si+24]
    cwd
    push    dx
    push    ax
    mov    bx,word ptr [si+2]
    call    word ptr [bx+30]
    add    sp,8
    mov    word ptr [si+145],ax
    ;
    ;                 (long) cinfo->color_out_comps);
    ;
    ;      /* Allocate Floyd-Steinberg workspace if necessary */
    ;      /* This isn't needed until pass 2, but again it is FAR storage. */
    ;
    cmp    word ptr [si+22],0
    je    short @14@266
    ;
    ;      if (cinfo->use_dithering) {
    ;
    mov    cx,word ptr [si+38]
    mov    bx,word ptr [si+36]
    add    bx,2
    adc    cx,0
    xor    dx,dx
    mov    ax,6
    call    near ptr N_LXMUL@
    mov    word ptr [bp-2],ax
    ;
    ;        size_t arraysize = (size_t) ((cinfo->image_width + 2L) * 3L * SIZEOF(FSERROR));
    ;
    ;
    push    word ptr [bp-2]
    mov    bx,word ptr [si+2]
    call    word ptr [bx+26]
    inc    sp
    inc    sp
    mov    word ptr DGROUP:evenrowerrs+2,dx
    mov    word ptr DGROUP:evenrowerrs,ax
   ;
   ;        evenrowerrs = (FSERRPTR) (*cinfo->emethods->alloc_medium) (arraysize);
   ;
    push    word ptr [bp-2]
    mov    bx,word ptr [si+2]
    call    word ptr [bx+26]
    inc    sp
    inc    sp
    mov    word ptr DGROUP:oddrowerrs+2,dx
    mov    word ptr DGROUP:oddrowerrs,ax
   ;
   ;        oddrowerrs  = (FSERRPTR) (*cinfo->emethods->alloc_medium) (arraysize);
   ;        /* we only need to zero the forward contribution for current row. */
   ;
    push    word ptr [bp-2]
    push    word ptr DGROUP:evenrowerrs+2
    push    word ptr DGROUP:evenrowerrs
    call    near ptr _jzero_far
    add    sp,6
   ;
   ;        jzero_far((void FAR *) evenrowerrs, arraysize);
   ;
    mov    word ptr DGROUP:on_odd_row,0
@14@266:
   ;
   ;        on_odd_row = FALSE;
   ;      }
   ;
   ;      /* Indicate number of passes needed, excluding the prescan pass. */
   ;
    inc    word ptr [si+147]
   ;
    ;      cinfo->total_passes++;    /* I always use one pass */
   ;
    pop    di
    pop    si
    leave
    ret
color_quant_init    endp
   ;
   ;    METHODDEF void
   ;
    assume    cs:_TEXT
color_quant_doit    proc    near
    push    bp
    mov    bp,sp
    push    si
    push    di
    mov    si,word ptr [bp+4]
   ;
   ;    color_quant_doit (decompress_info_ptr cinfo, quantize_caller_ptr source_method)
   ;    {
   ;      int i;
   ;
   ;      /* Select the representative colors */
   ;
    push    si
    call    near ptr select_colors
    inc    sp
    inc    sp
   ;
   ;      select_colors(cinfo);
   ;      /* Pass the external colormap to the output module. */
   ;      /* NB: the output module may continue to use the colormap until shutdown. */
   ;
   ;
   ;      (*cinfo->methods->put_color_map) (cinfo, cinfo->actual_number_of_colors,
   ;
    push    word ptr [si+145]
    push    word ptr [si+143]
    push    si
    mov    bx,word ptr [si]
    call    word ptr [bx+60]
    add    sp,6
   ;
   ;                        cinfo->colormap);
    ;      /* Re-zero the histogram so pass 2 can use it as nearest-color cache */
    ;
    xor    di,di
    jmp    short @15@98
@15@50:
   ;
   ;      for (i = 0; i < HIST_Y_ELEMS; i++) {
   ;
   ;
   ;        jzero_far((void FAR *) histogram[i],
   ;
    push    2048
    mov    ax,di
    shl    ax,2
    mov    bx,word ptr DGROUP:histogram
    add    bx,ax
    push    word ptr [bx+2]
    push    word ptr [bx]
    call    near ptr _jzero_far
    add    sp,6
    inc    di
@15@98:
    cmp    di,64
    jl    short @15@50
   ;
   ;              HIST_C_ELEMS*HIST_C_ELEMS * SIZEOF(histcell));
   ;      }
    ;      /* Perform pass 2 */
   ;
    cmp    word ptr [si+22],0
    je    short @15@170
   ;
   ;      if (cinfo->use_dithering)
   ;
    push    offset pass2_dither
    jmp    short @15@194
@15@170:
   ;
   ;        (*source_method) (cinfo, pass2_dither);
   ;      else
   ;
    push    offset pass2_nodither
@15@194:
    push    si
    call    word ptr [bp+6]
    add    sp,4
   ;
   ;        (*source_method) (cinfo, pass2_nodither);
   ;
    pop    di
    pop    si
    pop    bp
    ret
color_quant_doit    endp
   ;
   ;    METHODDEF void
   ;
    assume    cs:_TEXT
color_quant_term    proc    near
    push    bp
    mov    bp,sp
   ;
   ;    color_quant_term (decompress_info_ptr cinfo)
   ;    {
   ;      /* no work (we let free_all release the histogram/cache and colormaps) */
   ;      /* Note that we *mustn't* free the external colormap before free_all, */
   ;      /* since output module may use it! */
   ;
    pop    bp
    ret
color_quant_term    endp
    ;
   ;    METHODDEF void
   ;
    assume    cs:_TEXT
color_quantize    proc    near
    push    bp
    mov    bp,sp
    push    si
    mov    si,word ptr [bp+4]
   ;
   ;    color_quantize (decompress_info_ptr cinfo, int num_rows,
   ;            JSAMPIMAGE input_data, JSAMPARRAY output_data)
   ;    {
   ;
    push    offset DGROUP:s@+125
    mov    bx,word ptr [si+2]
    call    word ptr [bx]
    inc    sp
    inc    sp
   ;
   ;      ERREXIT(cinfo->emethods, "Should not get here!");
   ;
    pop    si
    pop    bp
    ret
color_quantize    endp
   ;
   ;    GLOBAL void
   ;
    assume    cs:_TEXT
_jsel2quantize    proc    near
    push    bp
    mov    bp,sp
    push    si
    mov    si,word ptr [bp+4]
   ;
   ;    jsel2quantize (decompress_info_ptr cinfo)
   ;    {
   ;
    cmp    word ptr [si+20],0
    je    short @18@146
   ;
   ;      if (cinfo->two_pass_quantize) {
   ;        /* Make sure jdmaster didn't give me a case I can't handle */
    ;
    cmp    word ptr [si+53],3
    jne    short @18@98
    cmp    word ptr [si+46],3
    je    short @18@122
@18@98:
   ;
   ;        if (cinfo->num_components != 3 || cinfo->jpeg_color_space != CS_YCbCr)
   ;
    push    offset DGROUP:s@+146
    mov    bx,word ptr [si+2]
    call    word ptr [bx]
    inc    sp
    inc    sp
@18@122:
   ;
   ;          ERREXIT(cinfo->emethods, "2-pass quantization only handles YCbCr input");
    ;
    mov    bx,word ptr [si]
    mov    word ptr [bx+48],offset color_quant_init
   ;
   ;        cinfo->methods->color_quant_init = color_quant_init;
   ;
    mov    bx,word ptr [si]
    mov    word ptr [bx+52],offset color_quant_prescan
   ;
   ;        cinfo->methods->color_quant_prescan = color_quant_prescan;
   ;
    mov    bx,word ptr [si]
    mov    word ptr [bx+54],offset color_quant_doit
   ;
   ;        cinfo->methods->color_quant_doit = color_quant_doit;
   ;
    mov    bx,word ptr [si]
    mov    word ptr [bx+56],offset color_quant_term
   ;
   ;        cinfo->methods->color_quant_term = color_quant_term;
   ;
    mov    bx,word ptr [si]
    mov    word ptr [bx+50],offset color_quantize
@18@146:
   ;
   ;        cinfo->methods->color_quantize = color_quantize;
   ;      }
    ;
    pop    si
    pop    bp
    ret
_jsel2quantize    endp
_TEXT    ends
_BSS    segment word public 'BSS'
on_odd_row    label    word
    db    2 dup (?)
evenrowerrs    label    dword
    db    4 dup (?)
boxlist    label    word
    db    2 dup (?)
oddrowerrs    label    dword
    db    4 dup (?)
numboxes    label    word
    db    2 dup (?)
histogram    label    word
    db    2 dup (?)
my_colormap    label    word
    db    2 dup (?)
_BSS    ends
_DATA    segment word public 'DATA'
s@    label    byte
    db    'Selected %d colors for quantization'
    db    0
    db    'Cannot request less than 8 quantized colors'
    db    0
    db    'Cannot request more than %d quantized colors'
    db    0
    db    'Should not get here!'
    db    0
    db    '2-pass quantization only handles YCbCr input'
    db    0
_DATA    ends
_TEXT    segment byte public 'CODE'
_TEXT    ends
    extrn    _jzero_far:near
_pass2_dither    equ    pass2_dither
_median_cut    equ    median_cut
_my_colormap    equ    my_colormap
_color_quant_prescan    equ    color_quant_prescan
_color_quant_term    equ    color_quant_term
_color_quantize    equ    color_quantize
_histogram    equ    histogram
_color_quant_doit    equ    color_quant_doit
_color_quant_init    equ    color_quant_init
_numboxes    equ    numboxes
_oddrowerrs    equ    oddrowerrs
    public    _jsel2quantize
_update_box    equ    update_box
_find_biggest_color_pop    equ    find_biggest_color_pop
_compute_color    equ    compute_color
_find_biggest_volume    equ    find_biggest_volume
_find_nearby_colors    equ    find_nearby_colors
_find_best_colors    equ    find_best_colors
    extrn    N_LDIV@:far
_boxlist    equ    boxlist
_evenrowerrs    equ    evenrowerrs
_fill_inverse_cmap    equ    fill_inverse_cmap
    extrn    N_LXMUL@:far
    extrn    N_LXLSH@:far
_on_odd_row    equ    on_odd_row
_select_colors    equ    select_colors
_pass2_nodither    equ    pass2_nodither
_remap_colormap    equ    remap_colormap
    end